@pibbl/core 0.0.1

package/dist/lib/animation/program.js

@@ -0,0 +1,741 @@
+import { getSignalNode, isSignal } from "../signals/graph.js";
+import { getDefinitionRecord } from "./definition.js";
+const programRecords = /* @__PURE__ */ new WeakMap();
+const exactSeekableDurations = /* @__PURE__ */ new WeakMap();
+const activationDependentWriterOutputs = /* @__PURE__ */ new WeakMap();
+const finite = (milliseconds) => Object.freeze({
+  kind: "finite",
+  milliseconds
+});
+const infinite = Object.freeze({ kind: "infinite" });
+const unresolved = Object.freeze({ kind: "unresolved-stepper" });
+function freezePath(path) {
+  return Object.freeze([...path]);
+}
+function freezeSpan(output, start, end, path) {
+  return Object.freeze({ output, start, end, path: freezePath(path) });
+}
+function freezeSchedule(span, repeats = []) {
+  return Object.freeze({
+    span,
+    repeats: Object.freeze(repeats.map((repeat2) => Object.freeze({ ...repeat2 })))
+  });
+}
+function finiteWriterSpans(schedules) {
+  return Object.freeze(schedules.map((schedule) => schedule.span));
+}
+function outputsFor(schedules) {
+  const outputs = [];
+  for (const schedule of schedules) {
+    if (!outputs.includes(schedule.span.output)) outputs.push(schedule.span.output);
+  }
+  return Object.freeze(outputs);
+}
+function createProgram(record) {
+  const program = Object.freeze({});
+  programRecords.set(program, Object.freeze(record));
+  return program;
+}
+function programLabel(path) {
+  return `[${path.join(", ")}]`;
+}
+function definitionDuration(definition) {
+  const record = getDefinitionRecord(definition);
+  if (record.kind !== "stepper") return finite(record.duration);
+  return record.done === void 0 ? infinite : unresolved;
+}
+function assertWritableSignal(output) {
+  if (!isSignal(output) || typeof output.set !== "function" || typeof output.update !== "function") {
+    throw new TypeError("Expected a writable signal created by signal().");
+  }
+  return output;
+}
+function prefixedSchedules(schedules, childIndex, offset) {
+  return Object.freeze(schedules.map((schedule) => freezeSchedule(
+    freezeSpan(
+      schedule.span.output,
+      schedule.span.start + offset,
+      schedule.span.end + offset,
+      [childIndex, ...schedule.span.path]
+    ),
+    schedule.repeats
+  )));
+}
+function normalizedRepeats(repeats) {
+  const normalized = [];
+  for (const repeat2 of repeats) {
+    if (repeat2.iterations === 1) continue;
+    const previous = normalized.at(-1);
+    const combinedIterations = previous === void 0 ? Number.NaN : previous.iterations * repeat2.iterations;
+    if (previous !== void 0 && repeat2.period === previous.period * previous.iterations && Number.isFinite(combinedIterations) && Number.isInteger(combinedIterations)) {
+      normalized[normalized.length - 1] = { period: previous.period, iterations: combinedIterations };
+    } else {
+      normalized.push({ period: repeat2.period, iterations: repeat2.iterations });
+    }
+  }
+  return Object.freeze(normalized.map((repeat2) => Object.freeze(repeat2)));
+}
+function withRepeat(schedules, period, iterations) {
+  return Object.freeze(schedules.map((schedule) => freezeSchedule(schedule.span, normalizedRepeats([
+    ...schedule.repeats,
+    { period, iterations }
+  ]))));
+}
+const maximumNestedAlignmentDescents = 512;
+class OverlapProofBudgetExceeded extends Error {
+}
+const numberBits = new DataView(new ArrayBuffer(8));
+function dyadic(value) {
+  numberBits.setFloat64(0, value, false);
+  const high = numberBits.getUint32(0, false);
+  const low = numberBits.getUint32(4, false);
+  const fraction = BigInt(high & 1048575) << 32n | BigInt(low);
+  const exponentBits = high >>> 20 & 2047;
+  if (exponentBits === 0 && fraction === 0n) return { numerator: 0n, exponent: 0 };
+  if (exponentBits === 0) return { numerator: fraction, exponent: -1074 };
+  return {
+    numerator: 1n << 52n | fraction,
+    exponent: exponentBits - 1023 - 52
+  };
+}
+function exactScheduleValues(schedule) {
+  return [
+    schedule.span.start,
+    schedule.span.end,
+    ...schedule.repeats.map((repeat2) => repeat2.period)
+  ];
+}
+function commonDyadicExponent(first, second) {
+  const values = [...exactScheduleValues(first), ...exactScheduleValues(second)].map(dyadic).filter((value) => value.numerator !== 0n);
+  return values.length === 0 ? 0 : Math.min(...values.map((value) => value.exponent));
+}
+function scaleDyadic(value, exponent) {
+  const exact = dyadic(value);
+  return exact.numerator << BigInt(exact.exponent - exponent);
+}
+function exactSchedule(schedule, exponent) {
+  return {
+    span: {
+      start: scaleDyadic(schedule.span.start, exponent),
+      end: scaleDyadic(schedule.span.end, exponent)
+    },
+    repeats: schedule.repeats.map((repeat2) => ({
+      period: scaleDyadic(repeat2.period, exponent),
+      iterations: repeat2.iterations
+    }))
+  };
+}
+function floorDivide(value, divisor) {
+  if (value >= 0n) return value / divisor;
+  return -((-value + divisor - 1n) / divisor);
+}
+function ceilDivide(value, divisor) {
+  return -floorDivide(-value, divisor);
+}
+function clamp(value, minimum, maximum) {
+  return value < minimum ? minimum : value > maximum ? maximum : value;
+}
+function greatestCommonDivisor(first, second) {
+  let left = first;
+  let right = second;
+  while (right !== 0n) {
+    const remainder = left % right;
+    left = right;
+    right = remainder;
+  }
+  return left;
+}
+function floorSum(count, divisor, multiplier, offset) {
+  let currentCount = count;
+  let currentDivisor = divisor;
+  let currentMultiplier = multiplier;
+  let currentOffset = offset;
+  let result = 0n;
+  while (true) {
+    if (currentMultiplier >= currentDivisor) {
+      result += (currentCount - 1n) * currentCount * (currentMultiplier / currentDivisor) / 2n;
+      currentMultiplier %= currentDivisor;
+    }
+    if (currentOffset >= currentDivisor) {
+      result += currentCount * (currentOffset / currentDivisor);
+      currentOffset %= currentDivisor;
+    }
+    const maximum = currentMultiplier * currentCount + currentOffset;
+    if (maximum < currentDivisor) return result;
+    currentCount = maximum / currentDivisor;
+    currentOffset = maximum % currentDivisor;
+    const previousDivisor = currentDivisor;
+    currentDivisor = currentMultiplier;
+    currentMultiplier = previousDivisor;
+  }
+}
+function boundedLinearCount(firstPeriod, firstIterations, secondPeriod, secondIterations, limit) {
+  if (limit < 0n) return 0n;
+  const nonemptyFirst = clamp(floorDivide(limit, firstPeriod) + 1n, 0n, firstIterations);
+  if (nonemptyFirst === 0n) return 0n;
+  const completeFirst = clamp(
+    floorDivide(limit - secondPeriod * (secondIterations - 1n), firstPeriod) + 1n,
+    0n,
+    nonemptyFirst
+  );
+  const partialCount = nonemptyFirst - completeFirst;
+  if (partialCount === 0n) return completeFirst * secondIterations;
+  const reverseOffset = limit - firstPeriod * (nonemptyFirst - 1n);
+  return completeFirst * secondIterations + partialCount + floorSum(
+    partialCount,
+    secondPeriod,
+    firstPeriod,
+    reverseOffset
+  );
+}
+function boundedIndexRangeExists(first, last, iterations) {
+  if (last < 0n) return false;
+  if (iterations === Number.POSITIVE_INFINITY) return first <= last;
+  const maximum = BigInt(iterations) - 1n;
+  return first <= maximum && clamp(first, 0n, maximum) <= clamp(last, 0n, maximum);
+}
+function boundedDifferenceExists(firstPeriod, firstIterations, secondPeriod, secondIterations, lower, upper) {
+  if (lower > upper) return false;
+  if (firstPeriod === 0n && secondPeriod === 0n) return lower <= 0n && 0n <= upper;
+  if (firstPeriod === 0n) {
+    return boundedIndexRangeExists(
+      ceilDivide(lower, secondPeriod),
+      floorDivide(upper, secondPeriod),
+      secondIterations
+    );
+  }
+  if (secondPeriod === 0n) {
+    return boundedIndexRangeExists(
+      ceilDivide(-upper, firstPeriod),
+      floorDivide(-lower, firstPeriod),
+      firstIterations
+    );
+  }
+  if (firstIterations === Number.POSITIVE_INFINITY && secondIterations === Number.POSITIVE_INFINITY) {
+    const increment = greatestCommonDivisor(firstPeriod, secondPeriod);
+    return ceilDivide(lower, increment) * increment <= upper;
+  }
+  const boundedFirstIterations = firstIterations === Number.POSITIVE_INFINITY ? floorDivide(
+    secondPeriod * (BigInt(secondIterations) - 1n) - lower,
+    firstPeriod
+  ) + 1n : BigInt(firstIterations);
+  const boundedSecondIterations = secondIterations === Number.POSITIVE_INFINITY ? floorDivide(
+    upper + firstPeriod * (BigInt(firstIterations) - 1n),
+    secondPeriod
+  ) + 1n : BigInt(secondIterations);
+  if (boundedFirstIterations <= 0n || boundedSecondIterations <= 0n) return false;
+  const translatedUpper = upper + firstPeriod * (boundedFirstIterations - 1n);
+  const translatedBelowLower = lower - 1n + firstPeriod * (boundedFirstIterations - 1n);
+  const atMostUpper = boundedLinearCount(
+    firstPeriod,
+    boundedFirstIterations,
+    secondPeriod,
+    boundedSecondIterations,
+    translatedUpper
+  );
+  const belowLower = boundedLinearCount(
+    firstPeriod,
+    boundedFirstIterations,
+    secondPeriod,
+    boundedSecondIterations,
+    translatedBelowLower
+  );
+  return atMostUpper > belowLower;
+}
+function leastBoundedDifference(firstPeriod, firstIterations, secondPeriod, secondIterations, lower, upper) {
+  if (!boundedDifferenceExists(
+    firstPeriod,
+    firstIterations,
+    secondPeriod,
+    secondIterations,
+    lower,
+    upper
+  )) return void 0;
+  let start = lower;
+  let end = upper;
+  while (start < end) {
+    const middle = floorDivide(start + end, 2n);
+    if (boundedDifferenceExists(
+      firstPeriod,
+      firstIterations,
+      secondPeriod,
+      secondIterations,
+      lower,
+      middle
+    )) {
+      end = middle;
+    } else {
+      start = middle + 1n;
+    }
+  }
+  return start;
+}
+function oneRepeatSchedule(schedule) {
+  if (schedule.repeats.length === 0) {
+    return { span: schedule.span, period: 0n, iterations: 1 };
+  }
+  if (schedule.repeats.length !== 1) return void 0;
+  const repeat2 = schedule.repeats[0];
+  return { span: schedule.span, period: repeat2.period, iterations: repeat2.iterations };
+}
+function fixedAgainstPeriodic(fixed, periodic) {
+  return boundedIndexRangeExists(
+    ceilDivide(fixed.start - periodic.span.end, periodic.period),
+    floorDivide(fixed.end - periodic.span.start, periodic.period),
+    periodic.iterations
+  );
+}
+function arithmeticSchedulesOverlap(first, second) {
+  if (first.period === 0n && second.period === 0n) {
+    return first.span.start <= second.span.end && second.span.start <= first.span.end;
+  }
+  if (first.period === 0n) return fixedAgainstPeriodic(first.span, second);
+  if (second.period === 0n) return fixedAgainstPeriodic(second.span, first);
+  return boundedDifferenceExists(
+    first.period,
+    first.iterations,
+    second.period,
+    second.iterations,
+    first.span.start - second.span.end,
+    first.span.end - second.span.start
+  );
+}
+function scheduleRange(schedule) {
+  const offset = schedule.repeats.reduce(
+    (total, repeat2) => total + (repeat2.iterations - 1) * repeat2.period,
+    0
+  );
+  return Object.freeze({ start: schedule.span.start, end: schedule.span.end + offset });
+}
+function exactScheduleRange(schedule) {
+  let end = schedule.span.end;
+  for (const repeat2 of schedule.repeats) {
+    if (repeat2.iterations === Number.POSITIVE_INFINITY) {
+      throw new Error("An infinite repeat frame cannot be nested inside another finite frame.");
+    }
+    end += (BigInt(repeat2.iterations) - 1n) * repeat2.period;
+  }
+  return { start: schedule.span.start, end };
+}
+function withoutOuterRepeat(schedule) {
+  return { span: schedule.span, repeats: schedule.repeats.slice(0, -1) };
+}
+function shiftedSchedule(schedule, offset) {
+  return {
+    span: {
+      start: schedule.span.start + offset,
+      end: schedule.span.end + offset
+    },
+    repeats: schedule.repeats
+  };
+}
+function symbolicOuterRepeatOverlap(first, second, budget) {
+  const firstOuter = first.repeats.at(-1);
+  const secondOuter = second.repeats.at(-1);
+  const firstInner = withoutOuterRepeat(first);
+  const secondInner = withoutOuterRepeat(second);
+  const firstRange = exactScheduleRange(firstInner);
+  const secondRange = exactScheduleRange(secondInner);
+  const lower = firstRange.start - secondRange.end;
+  const upper = firstRange.end - secondRange.start;
+  let difference = leastBoundedDifference(
+    firstOuter.period,
+    firstOuter.iterations,
+    secondOuter.period,
+    secondOuter.iterations,
+    lower,
+    upper
+  );
+  while (difference !== void 0) {
+    if (budget.remainingAlignments === 0) throw new OverlapProofBudgetExceeded();
+    budget.remainingAlignments--;
+    if (exactSchedulesOverlap(
+      firstInner,
+      shiftedSchedule(secondInner, difference),
+      budget
+    )) return true;
+    if (difference === upper) return false;
+    difference = leastBoundedDifference(
+      firstOuter.period,
+      firstOuter.iterations,
+      secondOuter.period,
+      secondOuter.iterations,
+      difference + 1n,
+      upper
+    );
+  }
+  return false;
+}
+function nextScheduleTime(schedule, target) {
+  const outer = schedule.repeats.at(-1);
+  if (outer === void 0) {
+    if (target > schedule.span.end) return void 0;
+    return target > schedule.span.start ? target : schedule.span.start;
+  }
+  const inner = withoutOuterRepeat(schedule);
+  const innerRange = exactScheduleRange(inner);
+  let iteration = ceilDivide(target - innerRange.end, outer.period);
+  if (iteration < 0n) iteration = 0n;
+  const maximum = outer.iterations === Number.POSITIVE_INFINITY ? void 0 : BigInt(outer.iterations) - 1n;
+  if (maximum !== void 0 && iteration > maximum) return void 0;
+  const offset = iteration * outer.period;
+  const innerTime = nextScheduleTime(inner, target - offset);
+  if (innerTime !== void 0) return innerTime + offset;
+  iteration += 1n;
+  if (maximum !== void 0 && iteration > maximum) return void 0;
+  return innerRange.start + iteration * outer.period;
+}
+function repeatAgainstStaticOverlap(repeated, staticSchedule) {
+  const first = nextScheduleTime(repeated, staticSchedule.span.start);
+  return first !== void 0 && first <= staticSchedule.span.end;
+}
+function exactSchedulesOverlap(first, second, budget) {
+  const firstArithmetic = oneRepeatSchedule(first);
+  const secondArithmetic = oneRepeatSchedule(second);
+  if (firstArithmetic !== void 0 && secondArithmetic !== void 0) {
+    return arithmeticSchedulesOverlap(firstArithmetic, secondArithmetic);
+  }
+  const firstOuter = first.repeats.at(-1);
+  const secondOuter = second.repeats.at(-1);
+  if (firstOuter !== void 0 && secondOuter !== void 0) {
+    return symbolicOuterRepeatOverlap(first, second, budget);
+  }
+  if (firstOuter !== void 0) return repeatAgainstStaticOverlap(first, second);
+  if (secondOuter !== void 0) return repeatAgainstStaticOverlap(second, first);
+  return false;
+}
+function schedulesOverlap(first, second) {
+  if (!Number.isFinite(first.span.end) || !Number.isFinite(second.span.end)) {
+    const firstRange = scheduleRange(first);
+    const secondRange = scheduleRange(second);
+    return firstRange.start <= secondRange.end && secondRange.start <= firstRange.end;
+  }
+  const exponent = commonDyadicExponent(first, second);
+  try {
+    return exactSchedulesOverlap(
+      exactSchedule(first, exponent),
+      exactSchedule(second, exponent),
+      { remainingAlignments: maximumNestedAlignmentDescents }
+    );
+  } catch (error) {
+    if (!(error instanceof OverlapProofBudgetExceeded)) throw error;
+    const name = getSignalNode(first.span.output).debugName ?? "<unnamed signal>";
+    throw new RangeError(
+      `Animation program cannot prove nested same-output writer schedules at paths ${programLabel(first.span.path)} and ${programLabel(second.span.path)} are disjoint for signal "${name}" within its structural validation budget. Refactor the nested repeats into sequential programs or use nonoverlapping output signals.`,
+      { cause: error }
+    );
+  }
+}
+function throwWriterConflict(first, second) {
+  const name = getSignalNode(first.span.output).debugName ?? "<unnamed signal>";
+  throw new RangeError(
+    `Animation program writers at paths ${programLabel(first.span.path)} and ${programLabel(second.span.path)} overlap for signal "${name}".`
+  );
+}
+function validateParallelChildren(children) {
+  for (let firstIndex = 0; firstIndex < children.length; firstIndex++) {
+    for (let secondIndex = firstIndex + 1; secondIndex < children.length; secondIndex++) {
+      const firstSchedules = prefixedSchedules(children[firstIndex].writerSchedules, firstIndex, 0);
+      const secondSchedules = prefixedSchedules(children[secondIndex].writerSchedules, secondIndex, 0);
+      for (const first of firstSchedules) {
+        for (const second of secondSchedules) {
+          if (first.span.output === second.span.output && schedulesOverlap(first, second)) {
+            throwWriterConflict(first, second);
+          }
+        }
+      }
+    }
+  }
+}
+function validateRepeatSchedules(schedules, period, iterations) {
+  if (iterations < 2) return;
+  for (const first of schedules) {
+    const firstRange = scheduleRange(first);
+    for (const second of schedules) {
+      if (first.span.output !== second.span.output) continue;
+      const secondRange = scheduleRange(second);
+      if (firstRange.end > period + secondRange.start || period === 0 && firstRange.end === period + secondRange.start) {
+        throwWriterConflict(first, second);
+      }
+    }
+  }
+}
+function sequenceDuration(records) {
+  let milliseconds = 0;
+  for (let index = 0; index < records.length; index++) {
+    const duration = records[index].duration;
+    if (duration.kind === "finite") {
+      milliseconds += duration.milliseconds;
+      if (!Number.isFinite(milliseconds)) {
+        throw new RangeError("Pibbl animation program duration must be finite and representable.");
+      }
+      continue;
+    }
+    if (duration.kind === "infinite") {
+      if (records.slice(index + 1).some((record) => record.hasReachableWork)) {
+        throw new RangeError("A statically infinite animation program cannot precede reachable sequence content.");
+      }
+      return infinite;
+    }
+    return unresolved;
+  }
+  return finite(milliseconds);
+}
+function parallelDuration(records) {
+  if (records.some((record) => record.duration.kind === "infinite")) return infinite;
+  if (records.some((record) => record.duration.kind === "unresolved-stepper")) return unresolved;
+  return finite(Math.max(0, ...records.map(
+    (record) => record.duration.milliseconds
+  )));
+}
+function drive(output, definition) {
+  const writableOutput = assertWritableSignal(output);
+  const normalizedDefinition = definition;
+  const duration = definitionDuration(normalizedDefinition);
+  const end = duration.kind === "finite" ? duration.milliseconds : Number.POSITIVE_INFINITY;
+  const schedule = freezeSchedule(freezeSpan(writableOutput, 0, end, []));
+  return createProgram({
+    kind: "track",
+    children: Object.freeze([]),
+    duration,
+    hasReachableWork: true,
+    output: writableOutput,
+    definition: normalizedDefinition,
+    outputs: Object.freeze([writableOutput]),
+    writerSchedules: Object.freeze([schedule]),
+    writerSpans: finiteWriterSpans([schedule])
+  });
+}
+function sequence(...children) {
+  const records = children.map(getProgramRecord);
+  const duration = sequenceDuration(records);
+  let offset = 0;
+  const schedules = [];
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    schedules.push(...prefixedSchedules(record.writerSchedules, index, offset));
+    if (record.duration.kind === "finite") offset += record.duration.milliseconds;
+  }
+  const frozenSchedules = Object.freeze(schedules);
+  return createProgram({
+    kind: "sequence",
+    children: Object.freeze([...children]),
+    duration,
+    hasReachableWork: records.some((record) => record.hasReachableWork),
+    outputs: outputsFor(frozenSchedules),
+    writerSchedules: frozenSchedules,
+    writerSpans: finiteWriterSpans(frozenSchedules)
+  });
+}
+function parallel(...children) {
+  const records = children.map(getProgramRecord);
+  validateParallelChildren(records);
+  const schedules = Object.freeze(records.flatMap(
+    (record, index) => prefixedSchedules(record.writerSchedules, index, 0)
+  ));
+  return createProgram({
+    kind: "parallel",
+    children: Object.freeze([...children]),
+    duration: parallelDuration(records),
+    hasReachableWork: records.some((record) => record.hasReachableWork),
+    outputs: outputsFor(schedules),
+    writerSchedules: schedules,
+    writerSpans: finiteWriterSpans(schedules)
+  });
+}
+function wait(duration) {
+  if (!Number.isFinite(duration) || duration < 0) {
+    throw new RangeError("Pibbl animation wait duration must be finite and nonnegative.");
+  }
+  return createProgram({
+    kind: "wait",
+    children: Object.freeze([]),
+    duration: finite(duration),
+    hasReachableWork: duration > 0,
+    outputs: Object.freeze([]),
+    writerSchedules: Object.freeze([]),
+    writerSpans: Object.freeze([])
+  });
+}
+function marker(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new TypeError("Pibbl animation marker name must be nonempty.");
+  }
+  return createProgram({
+    kind: "marker",
+    name,
+    children: Object.freeze([]),
+    duration: finite(0),
+    hasReachableWork: true,
+    outputs: Object.freeze([]),
+    writerSchedules: Object.freeze([]),
+    writerSpans: Object.freeze([])
+  });
+}
+function repeat(child, options) {
+  const childRecord = getProgramRecord(child);
+  const iterations = options?.iterations;
+  if (iterations !== Number.POSITIVE_INFINITY && (!Number.isInteger(iterations) || iterations < 1)) {
+    throw new RangeError("Pibbl animation repeat iterations must be an integer >= 1 or positive infinity.");
+  }
+  const direction = options?.direction ?? "normal";
+  if (direction !== "normal" && direction !== "reverse" && direction !== "alternate" && direction !== "alternate-reverse") {
+    throw new TypeError("Pibbl animation repeat direction must be normal, reverse, alternate, or alternate-reverse.");
+  }
+  const duration = iterations === Number.POSITIVE_INFINITY ? infinite : childRecord.duration.kind === "infinite" ? infinite : childRecord.duration.kind === "unresolved-stepper" ? unresolved : finiteProduct(childRecord.duration.milliseconds, iterations);
+  const childSchedules = prefixedSchedules(childRecord.writerSchedules, 0, 0);
+  if (childRecord.duration.kind === "finite") {
+    validateRepeatSchedules(
+      childSchedules,
+      childRecord.duration.milliseconds,
+      iterations
+    );
+  }
+  const schedules = childRecord.duration.kind === "finite" ? withRepeat(
+    childSchedules,
+    childRecord.duration.milliseconds,
+    iterations
+  ) : childSchedules;
+  return createProgram({
+    kind: "repeat",
+    children: Object.freeze([child]),
+    duration,
+    hasReachableWork: childRecord.hasReachableWork,
+    iterations,
+    direction,
+    outputs: outputsFor(schedules),
+    writerSchedules: schedules,
+    writerSpans: finiteWriterSpans(schedules)
+  });
+}
+function finiteProduct(milliseconds, iterations) {
+  const result = milliseconds * iterations;
+  if (!Number.isFinite(result)) {
+    throw new RangeError("Pibbl animation program duration must be finite and representable.");
+  }
+  return finite(result);
+}
+function getProgramRecord(program) {
+  const record = programRecords.get(program);
+  if (record === void 0) throw new TypeError("Expected a Pibbl animation program.");
+  return record;
+}
+function getExactSeekableProgramDuration(program) {
+  if (exactSeekableDurations.has(program)) return exactSeekableDurations.get(program);
+  const record = getProgramRecord(program);
+  let duration;
+  if (record.kind === "track") {
+    const definition = getDefinitionRecord(record.definition);
+    duration = definition.kind === "stepper" || definition.kind === "spring" && !definition.hasFrom ? void 0 : definition.duration;
+  } else if (record.kind === "wait") {
+    duration = record.duration.kind === "finite" ? record.duration.milliseconds : void 0;
+  } else if (record.kind === "marker") {
+    duration = 0;
+  } else {
+    const childDurations = record.children.map(getExactSeekableProgramDuration);
+    if (childDurations.some((childDuration) => childDuration === void 0)) {
+      duration = void 0;
+    } else if (record.kind === "sequence") {
+      duration = childDurations.reduce((total, childDuration) => total + childDuration, 0);
+    } else if (record.kind === "parallel") {
+      duration = Math.max(0, ...childDurations);
+    } else {
+      const childDuration = childDurations[0];
+      duration = record.iterations === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : childDuration * record.iterations;
+    }
+  }
+  exactSeekableDurations.set(program, duration);
+  return duration;
+}
+function resolvedSchedule(schedule) {
+  return freezeSchedule(
+    freezeSpan(schedule.output, schedule.start, schedule.end, schedule.path),
+    schedule.repeats
+  );
+}
+function resolvedWriterSchedulesOverlap(first, second) {
+  return schedulesOverlap(resolvedSchedule(first), resolvedSchedule(second));
+}
+function repeatResolvedWriterSchedules(schedules, period, iterations) {
+  return Object.freeze(withRepeat(
+    schedules.map(resolvedSchedule),
+    period,
+    iterations
+  ).map((schedule) => Object.freeze({
+    output: schedule.span.output,
+    start: schedule.span.start,
+    end: schedule.span.end,
+    path: freezePath(schedule.span.path),
+    repeats: schedule.repeats
+  })));
+}
+function dependentWriterOutputs(program) {
+  const cached = activationDependentWriterOutputs.get(program);
+  if (cached !== void 0) return cached;
+  const record = getProgramRecord(program);
+  const dependent = /* @__PURE__ */ new Set();
+  if (record.kind === "track") {
+    const definition = getDefinitionRecord(record.definition);
+    if (definition.kind === "spring" && !definition.hasFrom) {
+      dependent.add(record.output);
+    }
+  } else if (record.kind === "sequence") {
+    let prefixDurationDependsOnActivation = false;
+    for (const child of record.children) {
+      for (const output of dependentWriterOutputs(child)) dependent.add(output);
+      if (prefixDurationDependsOnActivation) {
+        for (const output of getProgramRecord(child).outputs) dependent.add(output);
+      }
+      if (getExactSeekableProgramDuration(child) === void 0) {
+        prefixDurationDependsOnActivation = true;
+      }
+    }
+  } else {
+    for (const child of record.children) {
+      for (const output of dependentWriterOutputs(child)) dependent.add(output);
+    }
+    if (record.kind === "repeat" && getExactSeekableProgramDuration(record.children[0]) === void 0 && (record.iterations > 1 || record.direction !== "normal")) {
+      for (const output of record.outputs) dependent.add(output);
+    }
+  }
+  activationDependentWriterOutputs.set(program, dependent);
+  return dependent;
+}
+function requiresActivationWriterSafetyAt(program) {
+  const record = getProgramRecord(program);
+  if (record.kind === "parallel") {
+    for (let firstIndex = 0; firstIndex < record.children.length; firstIndex++) {
+      for (let secondIndex = firstIndex + 1; secondIndex < record.children.length; secondIndex++) {
+        const first = record.children[firstIndex];
+        const second = record.children[secondIndex];
+        const secondOutputs = getProgramRecord(second).outputs;
+        const firstDependent = dependentWriterOutputs(first);
+        const secondDependent = dependentWriterOutputs(second);
+        if (getProgramRecord(first).outputs.some(
+          (candidate) => secondOutputs.includes(candidate) && (firstDependent.has(candidate) || secondDependent.has(candidate))
+        )) return true;
+      }
+    }
+  }
+  if (record.kind === "repeat" && record.iterations > 1 && getExactSeekableProgramDuration(record.children[0]) === void 0 && record.outputs.length > 0) {
+    return true;
+  }
+  return record.children.some(requiresActivationWriterSafetyAt);
+}
+function requiresProgramActivationWriterSafety(program) {
+  return requiresActivationWriterSafetyAt(program);
+}
+export {
+  drive,
+  getExactSeekableProgramDuration,
+  getProgramRecord,
+  marker,
+  parallel,
+  repeat,
+  repeatResolvedWriterSchedules,
+  requiresProgramActivationWriterSafety,
+  resolvedWriterSchedulesOverlap,
+  sequence,
+  wait
+};
+//# sourceMappingURL=program.js.map