@pibbl/core 0.0.1

package/dist/lib/animation/program.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/animation/program.ts"],
+  "sourcesContent": ["import { getSignalNode, isSignal } from '../signals/graph.js';\nimport type { WritableSignal } from '../signals/types.js';\nimport { getDefinitionRecord } from './definition.js';\nimport type {\n  PibblAnimationDefinition,\n  PibblAnimationProgram,\n  PibblAnimationRepeatDirection,\n  PibblAnimationRepeatOptions,\n} from './types.js';\n\nexport type ProgramDuration =\n  | { readonly kind: 'finite'; readonly milliseconds: number }\n  | { readonly kind: 'infinite' }\n  | { readonly kind: 'unresolved-stepper' };\n\nexport interface WriterSpan {\n  readonly output: WritableSignal<unknown>;\n  readonly start: number;\n  readonly end: number;\n  readonly path: readonly number[];\n}\n\ninterface WriterRepeatFrame {\n  readonly period: number;\n  readonly iterations: number;\n}\n\n/** @internal Activation-resolved symbolic writer schedule. */\nexport interface ResolvedWriterSchedule {\n  readonly output: WritableSignal<unknown>;\n  readonly start: number;\n  readonly end: number;\n  readonly path: readonly number[];\n  readonly repeats: readonly WriterRepeatFrame[];\n}\n\ninterface WriterSchedule {\n  readonly span: WriterSpan;\n  readonly repeats: readonly WriterRepeatFrame[];\n}\n\ninterface BaseProgramRecord {\n  readonly kind: 'track' | 'sequence' | 'parallel' | 'wait' | 'marker' | 'repeat';\n  readonly children: readonly PibblAnimationProgram[];\n  readonly duration: ProgramDuration;\n  readonly hasReachableWork: boolean;\n  readonly outputs: readonly WritableSignal<unknown>[];\n  readonly writerSpans: readonly WriterSpan[];\n  readonly writerSchedules: readonly WriterSchedule[];\n}\n\nexport interface TrackProgramRecord extends BaseProgramRecord {\n  readonly kind: 'track';\n  readonly output: WritableSignal<unknown>;\n  readonly definition: PibblAnimationDefinition<unknown>;\n}\n\nexport interface SequenceProgramRecord extends BaseProgramRecord {\n  readonly kind: 'sequence';\n}\n\nexport interface ParallelProgramRecord extends BaseProgramRecord {\n  readonly kind: 'parallel';\n}\n\nexport interface WaitProgramRecord extends BaseProgramRecord {\n  readonly kind: 'wait';\n}\n\nexport interface MarkerProgramRecord extends BaseProgramRecord {\n  readonly kind: 'marker';\n  readonly name: string;\n}\n\nexport interface RepeatProgramRecord extends BaseProgramRecord {\n  readonly kind: 'repeat';\n  readonly iterations: number;\n  readonly direction: PibblAnimationRepeatDirection;\n}\n\nexport type ProgramRecord =\n  | TrackProgramRecord\n  | SequenceProgramRecord\n  | ParallelProgramRecord\n  | WaitProgramRecord\n  | MarkerProgramRecord\n  | RepeatProgramRecord;\n\nconst programRecords = new WeakMap<PibblAnimationProgram, ProgramRecord>();\nconst exactSeekableDurations = new WeakMap<PibblAnimationProgram, number | undefined>();\nconst activationDependentWriterOutputs = new WeakMap<\n  PibblAnimationProgram,\n  ReadonlySet<WritableSignal<unknown>>\n>();\n\nconst finite = (milliseconds: number): ProgramDuration => Object.freeze({\n  kind: 'finite' as const,\n  milliseconds,\n});\nconst infinite: ProgramDuration = Object.freeze({ kind: 'infinite' as const });\nconst unresolved: ProgramDuration = Object.freeze({ kind: 'unresolved-stepper' as const });\n\nfunction freezePath(path: readonly number[]): readonly number[] {\n  return Object.freeze([...path]);\n}\n\nfunction freezeSpan(\n  output: WritableSignal<unknown>,\n  start: number,\n  end: number,\n  path: readonly number[],\n): WriterSpan {\n  return Object.freeze({ output, start, end, path: freezePath(path) });\n}\n\nfunction freezeSchedule(\n  span: WriterSpan,\n  repeats: readonly WriterRepeatFrame[] = [],\n): WriterSchedule {\n  return Object.freeze({\n    span,\n    repeats: Object.freeze(repeats.map(repeat => Object.freeze({ ...repeat }))),\n  });\n}\n\nfunction finiteWriterSpans(schedules: readonly WriterSchedule[]): readonly WriterSpan[] {\n  return Object.freeze(schedules.map(schedule => schedule.span));\n}\n\nfunction outputsFor(schedules: readonly WriterSchedule[]): readonly WritableSignal<unknown>[] {\n  const outputs: WritableSignal<unknown>[] = [];\n  for (const schedule of schedules) {\n    if (!outputs.includes(schedule.span.output)) outputs.push(schedule.span.output);\n  }\n  return Object.freeze(outputs);\n}\n\nfunction createProgram<T extends ProgramRecord>(record: T): PibblAnimationProgram {\n  const program = Object.freeze({}) as PibblAnimationProgram;\n  programRecords.set(program, Object.freeze(record) as ProgramRecord);\n  return program;\n}\n\nfunction programLabel(path: readonly number[]): string {\n  return `[${path.join(', ')}]`;\n}\n\nfunction definitionDuration(definition: PibblAnimationDefinition<unknown>): ProgramDuration {\n  const record = getDefinitionRecord(definition);\n  if (record.kind !== 'stepper') return finite(record.duration);\n  return record.done === undefined ? infinite : unresolved;\n}\n\nfunction assertWritableSignal<T>(output: WritableSignal<T>): WritableSignal<unknown> {\n  if (!isSignal(output) || typeof output.set !== 'function' || typeof output.update !== 'function') {\n    throw new TypeError('Expected a writable signal created by signal().');\n  }\n  return output as WritableSignal<unknown>;\n}\n\nfunction prefixedSchedules(\n  schedules: readonly WriterSchedule[],\n  childIndex: number,\n  offset: number,\n): readonly WriterSchedule[] {\n  return Object.freeze(schedules.map(schedule => freezeSchedule(\n    freezeSpan(\n      schedule.span.output,\n      schedule.span.start + offset,\n      schedule.span.end + offset,\n      [childIndex, ...schedule.span.path],\n    ),\n    schedule.repeats,\n  )));\n}\n\nfunction normalizedRepeats(\n  repeats: readonly WriterRepeatFrame[],\n): readonly WriterRepeatFrame[] {\n  const normalized: WriterRepeatFrame[] = [];\n  for (const repeat of repeats) {\n    if (repeat.iterations === 1) continue;\n    const previous = normalized.at(-1);\n    const combinedIterations = previous === undefined ? Number.NaN :\n      previous.iterations * repeat.iterations;\n    if (previous !== undefined &&\n      repeat.period === previous.period * previous.iterations &&\n      Number.isFinite(combinedIterations) && Number.isInteger(combinedIterations)) {\n      normalized[normalized.length - 1] = { period: previous.period, iterations: combinedIterations };\n    } else {\n      normalized.push({ period: repeat.period, iterations: repeat.iterations });\n    }\n  }\n  return Object.freeze(normalized.map(repeat => Object.freeze(repeat)));\n}\n\nfunction withRepeat(\n  schedules: readonly WriterSchedule[],\n  period: number,\n  iterations: number,\n): readonly WriterSchedule[] {\n  return Object.freeze(schedules.map(schedule => freezeSchedule(schedule.span, normalizedRepeats([\n    ...schedule.repeats,\n    { period, iterations },\n  ]))));\n}\n\ninterface Dyadic {\n  readonly exponent: number;\n  readonly numerator: bigint;\n}\n\ninterface ExactWriterSpan {\n  readonly start: bigint;\n  readonly end: bigint;\n}\n\ninterface ExactWriterRepeatFrame {\n  readonly period: bigint;\n  readonly iterations: number;\n}\n\ninterface ExactWriterSchedule {\n  readonly span: ExactWriterSpan;\n  readonly repeats: readonly ExactWriterRepeatFrame[];\n}\n\ninterface ExactArithmeticSchedule {\n  readonly span: ExactWriterSpan;\n  readonly period: bigint;\n  readonly iterations: number;\n}\n\ninterface OverlapProofBudget {\n  remainingAlignments: number;\n}\n\n/**\n * Caps exact recursive alignment descents during one writer-pair proof. This\n * is an availability boundary, not an acceptance shortcut: exhaustion rejects\n * the composition instead of claiming that the schedules are disjoint.\n */\nconst maximumNestedAlignmentDescents = 512;\n\nclass OverlapProofBudgetExceeded extends Error {}\n\nconst numberBits = new DataView(new ArrayBuffer(8));\n\nfunction dyadic(value: number): Dyadic {\n  numberBits.setFloat64(0, value, false);\n  const high = numberBits.getUint32(0, false);\n  const low = numberBits.getUint32(4, false);\n  const fraction = BigInt(high & 0x000f_ffff) << 32n | BigInt(low);\n  const exponentBits = (high >>> 20) & 0x7ff;\n  if (exponentBits === 0 && fraction === 0n) return { numerator: 0n, exponent: 0 };\n  if (exponentBits === 0) return { numerator: fraction, exponent: -1074 };\n  return {\n    numerator: (1n << 52n) | fraction,\n    exponent: exponentBits - 1023 - 52,\n  };\n}\n\nfunction exactScheduleValues(schedule: WriterSchedule): readonly number[] {\n  return [\n    schedule.span.start,\n    schedule.span.end,\n    ...schedule.repeats.map(repeat => repeat.period),\n  ];\n}\n\nfunction commonDyadicExponent(\n  first: WriterSchedule,\n  second: WriterSchedule,\n): number {\n  const values = [...exactScheduleValues(first), ...exactScheduleValues(second)]\n    .map(dyadic)\n    .filter(value => value.numerator !== 0n);\n  return values.length === 0 ? 0 : Math.min(...values.map(value => value.exponent));\n}\n\nfunction scaleDyadic(value: number, exponent: number): bigint {\n  const exact = dyadic(value);\n  return exact.numerator << BigInt(exact.exponent - exponent);\n}\n\nfunction exactSchedule(schedule: WriterSchedule, exponent: number): ExactWriterSchedule {\n  return {\n    span: {\n      start: scaleDyadic(schedule.span.start, exponent),\n      end: scaleDyadic(schedule.span.end, exponent),\n    },\n    repeats: schedule.repeats.map(repeat => ({\n      period: scaleDyadic(repeat.period, exponent),\n      iterations: repeat.iterations,\n    })),\n  };\n}\n\nfunction floorDivide(value: bigint, divisor: bigint): bigint {\n  if (value >= 0n) return value / divisor;\n  return -((-value + divisor - 1n) / divisor);\n}\n\nfunction ceilDivide(value: bigint, divisor: bigint): bigint {\n  return -floorDivide(-value, divisor);\n}\n\nfunction clamp(value: bigint, minimum: bigint, maximum: bigint): bigint {\n  return value < minimum ? minimum : value > maximum ? maximum : value;\n}\n\nfunction greatestCommonDivisor(first: bigint, second: bigint): bigint {\n  let left = first;\n  let right = second;\n  while (right !== 0n) {\n    const remainder = left % right;\n    left = right;\n    right = remainder;\n  }\n  return left;\n}\n\n/** Returns sum(floor((multiplier * i + offset) / divisor), i = 0..count). */\nfunction floorSum(\n  count: bigint,\n  divisor: bigint,\n  multiplier: bigint,\n  offset: bigint,\n): bigint {\n  let currentCount = count;\n  let currentDivisor = divisor;\n  let currentMultiplier = multiplier;\n  let currentOffset = offset;\n  let result = 0n;\n  while (true) {\n    if (currentMultiplier >= currentDivisor) {\n      result += (currentCount - 1n) * currentCount * (currentMultiplier / currentDivisor) / 2n;\n      currentMultiplier %= currentDivisor;\n    }\n    if (currentOffset >= currentDivisor) {\n      result += currentCount * (currentOffset / currentDivisor);\n      currentOffset %= currentDivisor;\n    }\n    const maximum = currentMultiplier * currentCount + currentOffset;\n    if (maximum < currentDivisor) return result;\n    currentCount = maximum / currentDivisor;\n    currentOffset = maximum % currentDivisor;\n    const previousDivisor = currentDivisor;\n    currentDivisor = currentMultiplier;\n    currentMultiplier = previousDivisor;\n  }\n}\n\n/** Counts bounded nonnegative pairs where a*i + b*j is at most limit. */\nfunction boundedLinearCount(\n  firstPeriod: bigint,\n  firstIterations: bigint,\n  secondPeriod: bigint,\n  secondIterations: bigint,\n  limit: bigint,\n): bigint {\n  if (limit < 0n) return 0n;\n  const nonemptyFirst = clamp(floorDivide(limit, firstPeriod) + 1n, 0n, firstIterations);\n  if (nonemptyFirst === 0n) return 0n;\n  const completeFirst = clamp(\n    floorDivide(limit - secondPeriod * (secondIterations - 1n), firstPeriod) + 1n,\n    0n,\n    nonemptyFirst,\n  );\n  const partialCount = nonemptyFirst - completeFirst;\n  if (partialCount === 0n) return completeFirst * secondIterations;\n  const reverseOffset = limit - firstPeriod * (nonemptyFirst - 1n);\n  return completeFirst * secondIterations + partialCount + floorSum(\n    partialCount,\n    secondPeriod,\n    firstPeriod,\n    reverseOffset,\n  );\n}\n\nfunction boundedIndexRangeExists(\n  first: bigint,\n  last: bigint,\n  iterations: number,\n): boolean {\n  if (last < 0n) return false;\n  if (iterations === Number.POSITIVE_INFINITY) return first <= last;\n  const maximum = BigInt(iterations) - 1n;\n  return first <= maximum && clamp(first, 0n, maximum) <= clamp(last, 0n, maximum);\n}\n\n/**\n * Tests lower <= secondPeriod*j - firstPeriod*i <= upper without visiting\n * either index domain. Infinite domains are first clipped to the finite band;\n * the remaining bounded rectangle is counted with Euclidean floor sums.\n */\nfunction boundedDifferenceExists(\n  firstPeriod: bigint,\n  firstIterations: number,\n  secondPeriod: bigint,\n  secondIterations: number,\n  lower: bigint,\n  upper: bigint,\n): boolean {\n  if (lower > upper) return false;\n  if (firstPeriod === 0n && secondPeriod === 0n) return lower <= 0n && 0n <= upper;\n  if (firstPeriod === 0n) {\n    return boundedIndexRangeExists(\n      ceilDivide(lower, secondPeriod),\n      floorDivide(upper, secondPeriod),\n      secondIterations,\n    );\n  }\n  if (secondPeriod === 0n) {\n    return boundedIndexRangeExists(\n      ceilDivide(-upper, firstPeriod),\n      floorDivide(-lower, firstPeriod),\n      firstIterations,\n    );\n  }\n  if (firstIterations === Number.POSITIVE_INFINITY &&\n    secondIterations === Number.POSITIVE_INFINITY) {\n    const increment = greatestCommonDivisor(firstPeriod, secondPeriod);\n    return ceilDivide(lower, increment) * increment <= upper;\n  }\n\n  const boundedFirstIterations = firstIterations === Number.POSITIVE_INFINITY ?\n    floorDivide(\n      secondPeriod * (BigInt(secondIterations) - 1n) - lower,\n      firstPeriod,\n    ) + 1n : BigInt(firstIterations);\n  const boundedSecondIterations = secondIterations === Number.POSITIVE_INFINITY ?\n    floorDivide(\n      upper + firstPeriod * (BigInt(firstIterations) - 1n),\n      secondPeriod,\n    ) + 1n : BigInt(secondIterations);\n  if (boundedFirstIterations <= 0n || boundedSecondIterations <= 0n) return false;\n\n  const translatedUpper = upper + firstPeriod * (boundedFirstIterations - 1n);\n  const translatedBelowLower = lower - 1n +\n    firstPeriod * (boundedFirstIterations - 1n);\n  const atMostUpper = boundedLinearCount(\n    firstPeriod,\n    boundedFirstIterations,\n    secondPeriod,\n    boundedSecondIterations,\n    translatedUpper,\n  );\n  const belowLower = boundedLinearCount(\n    firstPeriod,\n    boundedFirstIterations,\n    secondPeriod,\n    boundedSecondIterations,\n    translatedBelowLower,\n  );\n  return atMostUpper > belowLower;\n}\n\nfunction leastBoundedDifference(\n  firstPeriod: bigint,\n  firstIterations: number,\n  secondPeriod: bigint,\n  secondIterations: number,\n  lower: bigint,\n  upper: bigint,\n): bigint | undefined {\n  if (!boundedDifferenceExists(\n    firstPeriod,\n    firstIterations,\n    secondPeriod,\n    secondIterations,\n    lower,\n    upper,\n  )) return undefined;\n  let start = lower;\n  let end = upper;\n  while (start < end) {\n    const middle = floorDivide(start + end, 2n);\n    if (boundedDifferenceExists(\n      firstPeriod,\n      firstIterations,\n      secondPeriod,\n      secondIterations,\n      lower,\n      middle,\n    )) {\n      end = middle;\n    } else {\n      start = middle + 1n;\n    }\n  }\n  return start;\n}\n\nfunction oneRepeatSchedule(\n  schedule: ExactWriterSchedule,\n): ExactArithmeticSchedule | undefined {\n  if (schedule.repeats.length === 0) {\n    return { span: schedule.span, period: 0n, iterations: 1 };\n  }\n  if (schedule.repeats.length !== 1) return undefined;\n  const repeat = schedule.repeats[0]!;\n  return { span: schedule.span, period: repeat.period, iterations: repeat.iterations };\n}\n\nfunction fixedAgainstPeriodic(\n  fixed: ExactWriterSpan,\n  periodic: ExactArithmeticSchedule,\n): boolean {\n  return boundedIndexRangeExists(\n    ceilDivide(fixed.start - periodic.span.end, periodic.period),\n    floorDivide(fixed.end - periodic.span.start, periodic.period),\n    periodic.iterations,\n  );\n}\n\nfunction arithmeticSchedulesOverlap(\n  first: ExactArithmeticSchedule,\n  second: ExactArithmeticSchedule,\n): boolean {\n  if (first.period === 0n && second.period === 0n) {\n    return first.span.start <= second.span.end && second.span.start <= first.span.end;\n  }\n  if (first.period === 0n) return fixedAgainstPeriodic(first.span, second);\n  if (second.period === 0n) return fixedAgainstPeriodic(second.span, first);\n  return boundedDifferenceExists(\n    first.period,\n    first.iterations,\n    second.period,\n    second.iterations,\n    first.span.start - second.span.end,\n    first.span.end - second.span.start,\n  );\n}\n\nfunction scheduleRange(schedule: WriterSchedule): { readonly start: number; readonly end: number } {\n  const offset = schedule.repeats.reduce((total, repeat) =>\n    total + (repeat.iterations - 1) * repeat.period,\n  0);\n  return Object.freeze({ start: schedule.span.start, end: schedule.span.end + offset });\n}\n\nfunction exactScheduleRange(\n  schedule: ExactWriterSchedule,\n): { readonly start: bigint; readonly end: bigint } {\n  let end = schedule.span.end;\n  for (const repeat of schedule.repeats) {\n    if (repeat.iterations === Number.POSITIVE_INFINITY) {\n      throw new Error('An infinite repeat frame cannot be nested inside another finite frame.');\n    }\n    end += (BigInt(repeat.iterations) - 1n) * repeat.period;\n  }\n  return { start: schedule.span.start, end };\n}\n\nfunction withoutOuterRepeat(schedule: ExactWriterSchedule): ExactWriterSchedule {\n  return { span: schedule.span, repeats: schedule.repeats.slice(0, -1) };\n}\n\nfunction shiftedSchedule(\n  schedule: ExactWriterSchedule,\n  offset: bigint,\n): ExactWriterSchedule {\n  return {\n    span: {\n      start: schedule.span.start + offset,\n      end: schedule.span.end + offset,\n    },\n    repeats: schedule.repeats,\n  };\n}\n\nfunction symbolicOuterRepeatOverlap(\n  first: ExactWriterSchedule,\n  second: ExactWriterSchedule,\n  budget: OverlapProofBudget,\n): boolean {\n  const firstOuter = first.repeats.at(-1)!;\n  const secondOuter = second.repeats.at(-1)!;\n  const firstInner = withoutOuterRepeat(first);\n  const secondInner = withoutOuterRepeat(second);\n  const firstRange = exactScheduleRange(firstInner);\n  const secondRange = exactScheduleRange(secondInner);\n  const lower = firstRange.start - secondRange.end;\n  const upper = firstRange.end - secondRange.start;\n  let difference = leastBoundedDifference(\n    firstOuter.period,\n    firstOuter.iterations,\n    secondOuter.period,\n    secondOuter.iterations,\n    lower,\n    upper,\n  );\n  while (difference !== undefined) {\n    if (budget.remainingAlignments === 0) throw new OverlapProofBudgetExceeded();\n    budget.remainingAlignments--;\n    if (exactSchedulesOverlap(\n      firstInner,\n      shiftedSchedule(secondInner, difference),\n      budget,\n    )) return true;\n    if (difference === upper) return false;\n    difference = leastBoundedDifference(\n      firstOuter.period,\n      firstOuter.iterations,\n      secondOuter.period,\n      secondOuter.iterations,\n      difference + 1n,\n      upper,\n    );\n  }\n  return false;\n}\n\nfunction nextScheduleTime(\n  schedule: ExactWriterSchedule,\n  target: bigint,\n): bigint | undefined {\n  const outer = schedule.repeats.at(-1);\n  if (outer === undefined) {\n    if (target > schedule.span.end) return undefined;\n    return target > schedule.span.start ? target : schedule.span.start;\n  }\n  const inner = withoutOuterRepeat(schedule);\n  const innerRange = exactScheduleRange(inner);\n  let iteration = ceilDivide(target - innerRange.end, outer.period);\n  if (iteration < 0n) iteration = 0n;\n  const maximum = outer.iterations === Number.POSITIVE_INFINITY ? undefined :\n    BigInt(outer.iterations) - 1n;\n  if (maximum !== undefined && iteration > maximum) return undefined;\n  const offset = iteration * outer.period;\n  const innerTime = nextScheduleTime(inner, target - offset);\n  if (innerTime !== undefined) return innerTime + offset;\n  iteration += 1n;\n  if (maximum !== undefined && iteration > maximum) return undefined;\n  return innerRange.start + iteration * outer.period;\n}\n\nfunction repeatAgainstStaticOverlap(\n  repeated: ExactWriterSchedule,\n  staticSchedule: ExactWriterSchedule,\n): boolean {\n  const first = nextScheduleTime(repeated, staticSchedule.span.start);\n  return first !== undefined && first <= staticSchedule.span.end;\n}\n\nfunction exactSchedulesOverlap(\n  first: ExactWriterSchedule,\n  second: ExactWriterSchedule,\n  budget: OverlapProofBudget,\n): boolean {\n  const firstArithmetic = oneRepeatSchedule(first);\n  const secondArithmetic = oneRepeatSchedule(second);\n  if (firstArithmetic !== undefined && secondArithmetic !== undefined) {\n    return arithmeticSchedulesOverlap(firstArithmetic, secondArithmetic);\n  }\n  const firstOuter = first.repeats.at(-1);\n  const secondOuter = second.repeats.at(-1);\n  if (firstOuter !== undefined && secondOuter !== undefined) {\n    return symbolicOuterRepeatOverlap(first, second, budget);\n  }\n  if (firstOuter !== undefined) return repeatAgainstStaticOverlap(first, second);\n  if (secondOuter !== undefined) return repeatAgainstStaticOverlap(second, first);\n  return false;\n}\n\nfunction schedulesOverlap(first: WriterSchedule, second: WriterSchedule): boolean {\n  if (!Number.isFinite(first.span.end) || !Number.isFinite(second.span.end)) {\n    const firstRange = scheduleRange(first);\n    const secondRange = scheduleRange(second);\n    return firstRange.start <= secondRange.end && secondRange.start <= firstRange.end;\n  }\n  const exponent = commonDyadicExponent(first, second);\n  try {\n    return exactSchedulesOverlap(\n      exactSchedule(first, exponent),\n      exactSchedule(second, exponent),\n      { remainingAlignments: maximumNestedAlignmentDescents },\n    );\n  } catch (error) {\n    if (!(error instanceof OverlapProofBudgetExceeded)) throw error;\n    const name = getSignalNode(first.span.output).debugName ?? '<unnamed signal>';\n    throw new RangeError(\n      `Animation program cannot prove nested same-output writer schedules at paths ` +\n        `${programLabel(first.span.path)} and ${programLabel(second.span.path)} are disjoint ` +\n        `for signal \"${name}\" within its structural validation budget. Refactor the nested ` +\n        `repeats into sequential programs or use nonoverlapping output signals.`,\n      { cause: error },\n    );\n  }\n}\n\nfunction throwWriterConflict(first: WriterSchedule, second: WriterSchedule): never {\n  const name = getSignalNode(first.span.output).debugName ?? '<unnamed signal>';\n  throw new RangeError(\n    `Animation program writers at paths ${programLabel(first.span.path)} and ` +\n      `${programLabel(second.span.path)} overlap for signal \"${name}\".`,\n  );\n}\n\nfunction validateParallelChildren(children: readonly ProgramRecord[]): void {\n  for (let firstIndex = 0; firstIndex < children.length; firstIndex++) {\n    for (let secondIndex = firstIndex + 1; secondIndex < children.length; secondIndex++) {\n      const firstSchedules = prefixedSchedules(children[firstIndex]!.writerSchedules, firstIndex, 0);\n      const secondSchedules = prefixedSchedules(children[secondIndex]!.writerSchedules, secondIndex, 0);\n      for (const first of firstSchedules) {\n        for (const second of secondSchedules) {\n          if (first.span.output === second.span.output && schedulesOverlap(first, second)) {\n            throwWriterConflict(first, second);\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction validateRepeatSchedules(\n  schedules: readonly WriterSchedule[],\n  period: number,\n  iterations: number,\n): void {\n  if (iterations < 2) return;\n  for (const first of schedules) {\n    const firstRange = scheduleRange(first);\n    for (const second of schedules) {\n      if (first.span.output !== second.span.output) continue;\n      const secondRange = scheduleRange(second);\n      // Iterations are sequential: touching endpoints have source-order precedence.\n      // Zero-duration repeated writers retain the existing ambiguity guard.\n      if (firstRange.end > period + secondRange.start ||\n        (period === 0 && firstRange.end === period + secondRange.start)) {\n        throwWriterConflict(first, second);\n      }\n    }\n  }\n}\n\nfunction sequenceDuration(records: readonly ProgramRecord[]): ProgramDuration {\n  let milliseconds = 0;\n  for (let index = 0; index < records.length; index++) {\n    const duration = records[index]!.duration;\n    if (duration.kind === 'finite') {\n      milliseconds += duration.milliseconds;\n      if (!Number.isFinite(milliseconds)) {\n        throw new RangeError('Pibbl animation program duration must be finite and representable.');\n      }\n      continue;\n    }\n    if (duration.kind === 'infinite') {\n      if (records.slice(index + 1).some(record => record.hasReachableWork)) {\n        throw new RangeError('A statically infinite animation program cannot precede reachable sequence content.');\n      }\n      return infinite;\n    }\n    return unresolved;\n  }\n  return finite(milliseconds);\n}\n\nfunction parallelDuration(records: readonly ProgramRecord[]): ProgramDuration {\n  if (records.some(record => record.duration.kind === 'infinite')) return infinite;\n  if (records.some(record => record.duration.kind === 'unresolved-stepper')) return unresolved;\n  return finite(Math.max(0, ...records.map(record =>\n    (record.duration as Extract<ProgramDuration, { kind: 'finite' }>).milliseconds,\n  )));\n}\n\n/**\n * Binds one animation definition to one writable signal.\n *\n * @param output - Writable signal that receives sampled values. See {@link WritableSignal}.\n * @param definition - Animation definition to sample into the signal. See\n * {@link PibblAnimationDefinition} .\n * @returns A program that animates the supplied output signal. See {@link PibblAnimationProgram}.\n *\n * @see {@link WritableSignal}\n * @see {@link PibblAnimationDefinition}\n * @see {@link PibblAnimationProgram}\n */\nexport function drive<T>(\n  output: WritableSignal<T>,\n  definition: PibblAnimationDefinition<T>,\n): PibblAnimationProgram {\n  const writableOutput = assertWritableSignal(output);\n  const normalizedDefinition = definition as PibblAnimationDefinition<unknown>;\n  const duration = definitionDuration(normalizedDefinition);\n  const end = duration.kind === 'finite' ? duration.milliseconds : Number.POSITIVE_INFINITY;\n  const schedule = freezeSchedule(freezeSpan(writableOutput, 0, end, []));\n  return createProgram({\n    kind: 'track',\n    children: Object.freeze([]),\n    duration,\n    hasReachableWork: true,\n    output: writableOutput,\n    definition: normalizedDefinition,\n    outputs: Object.freeze([writableOutput]),\n    writerSchedules: Object.freeze([schedule]),\n    writerSpans: finiteWriterSpans([schedule]),\n  });\n}\n\n/**\n * Activates children in source order.\n *\n * @param children - Programs in execution order. See {@link PibblAnimationProgram}.\n * @returns A program that runs each child after its predecessor completes. See\n * {@link PibblAnimationProgram} .\n *\n * @see {@link PibblAnimationProgram}\n */\nexport function sequence(...children: readonly PibblAnimationProgram[]): PibblAnimationProgram {\n  const records = children.map(getProgramRecord);\n  const duration = sequenceDuration(records);\n  let offset = 0;\n  const schedules: WriterSchedule[] = [];\n  for (let index = 0; index < records.length; index++) {\n    const record = records[index]!;\n    schedules.push(...prefixedSchedules(record.writerSchedules, index, offset));\n    if (record.duration.kind === 'finite') offset += record.duration.milliseconds;\n  }\n  const frozenSchedules = Object.freeze(schedules);\n  return createProgram({\n    kind: 'sequence',\n    children: Object.freeze([...children]),\n    duration,\n    hasReachableWork: records.some(record => record.hasReachableWork),\n    outputs: outputsFor(frozenSchedules),\n    writerSchedules: frozenSchedules,\n    writerSpans: finiteWriterSpans(frozenSchedules),\n  });\n}\n\n/**\n * Activates all children from one shared local origin.\n *\n * @param children - Programs to begin together. See {@link PibblAnimationProgram}.\n * @returns A program whose children run concurrently. See {@link PibblAnimationProgram}.\n *\n * @see {@link PibblAnimationProgram}\n */\nexport function parallel(...children: readonly PibblAnimationProgram[]): PibblAnimationProgram {\n  const records = children.map(getProgramRecord);\n  validateParallelChildren(records);\n  const schedules = Object.freeze(records.flatMap((record, index) =>\n    prefixedSchedules(record.writerSchedules, index, 0),\n  ));\n  return createProgram({\n    kind: 'parallel',\n    children: Object.freeze([...children]),\n    duration: parallelDuration(records),\n    hasReachableWork: records.some(record => record.hasReachableWork),\n    outputs: outputsFor(schedules),\n    writerSchedules: schedules,\n    writerSpans: finiteWriterSpans(schedules),\n  });\n}\n\n/**\n * Adds finite nonnegative local time without writing an output.\n *\n * @param duration - Delay in milliseconds.\n * @returns A program that advances time without writing a value. See {@link PibblAnimationProgram}.\n *\n * @see {@link PibblAnimationProgram}\n */\nexport function wait(duration: number): PibblAnimationProgram {\n  if (!Number.isFinite(duration) || duration < 0) {\n    throw new RangeError('Pibbl animation wait duration must be finite and nonnegative.');\n  }\n  return createProgram({\n    kind: 'wait',\n    children: Object.freeze([]),\n    duration: finite(duration),\n    hasReachableWork: duration > 0,\n    outputs: Object.freeze([]),\n    writerSchedules: Object.freeze([]),\n    writerSpans: Object.freeze([]),\n  });\n}\n\n/**\n * Queues one named playback milestone without invoking user code.\n *\n * @param name - Name delivered when playback reaches this milestone.\n * @returns A zero-duration marker program. See {@link PibblAnimationProgram}.\n *\n * @see {@link PibblAnimationProgram}\n */\nexport function marker(name: string): PibblAnimationProgram {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw new TypeError('Pibbl animation marker name must be nonempty.');\n  }\n  return createProgram({\n    kind: 'marker',\n    name,\n    children: Object.freeze([]),\n    duration: finite(0),\n    hasReachableWork: true,\n    outputs: Object.freeze([]),\n    writerSchedules: Object.freeze([]),\n    writerSpans: Object.freeze([]),\n  });\n}\n\n/**\n * Repeats one child a total number of iterations.\n *\n * @param child - Program to repeat. See {@link PibblAnimationProgram}.\n * @param options - Repeat count and repetition policy. See {@link PibblAnimationRepeatOptions}.\n * @returns A program representing the requested repetitions. See {@link PibblAnimationProgram}.\n *\n * @see {@link PibblAnimationProgram}\n * @see {@link PibblAnimationRepeatOptions}\n */\nexport function repeat(\n  child: PibblAnimationProgram,\n  options: Readonly<PibblAnimationRepeatOptions>,\n): PibblAnimationProgram {\n  const childRecord = getProgramRecord(child);\n  const iterations = options?.iterations;\n  if (iterations !== Number.POSITIVE_INFINITY &&\n    (!Number.isInteger(iterations) || (iterations as number) < 1)) {\n    throw new RangeError('Pibbl animation repeat iterations must be an integer >= 1 or positive infinity.');\n  }\n  const direction = options?.direction ?? 'normal';\n  if (direction !== 'normal' && direction !== 'reverse' &&\n    direction !== 'alternate' && direction !== 'alternate-reverse') {\n    throw new TypeError('Pibbl animation repeat direction must be normal, reverse, alternate, or alternate-reverse.');\n  }\n  const duration = iterations === Number.POSITIVE_INFINITY ? infinite :\n    childRecord.duration.kind === 'infinite' ? infinite :\n      childRecord.duration.kind === 'unresolved-stepper' ? unresolved :\n        finiteProduct(childRecord.duration.milliseconds, iterations as number);\n  const childSchedules = prefixedSchedules(childRecord.writerSchedules, 0, 0);\n  if (childRecord.duration.kind === 'finite') {\n    validateRepeatSchedules(\n      childSchedules,\n      childRecord.duration.milliseconds,\n      iterations as number,\n    );\n  }\n  const schedules = childRecord.duration.kind === 'finite' ? withRepeat(\n    childSchedules,\n    childRecord.duration.milliseconds,\n    iterations as number,\n  ) : childSchedules;\n  return createProgram({\n    kind: 'repeat',\n    children: Object.freeze([child]),\n    duration,\n    hasReachableWork: childRecord.hasReachableWork,\n    iterations: iterations as number,\n    direction,\n    outputs: outputsFor(schedules),\n    writerSchedules: schedules,\n    writerSpans: finiteWriterSpans(schedules),\n  });\n}\n\nfunction finiteProduct(milliseconds: number, iterations: number): ProgramDuration {\n  const result = milliseconds * iterations;\n  if (!Number.isFinite(result)) {\n    throw new RangeError('Pibbl animation program duration must be finite and representable.');\n  }\n  return finite(result);\n}\n\n/** @internal Returns the private immutable record associated with a program. */\nexport function getProgramRecord(program: PibblAnimationProgram): ProgramRecord {\n  const record = programRecords.get(program);\n  if (record === undefined) throw new TypeError('Expected a Pibbl animation program.');\n  return record;\n}\n\n/**\n * @internal Returns a construction-time exact seekable duration when no track\n * needs activation data to resolve it. Positive infinity is exact; `undefined`\n * means activation or Task 5 state is required.\n */\nexport function getExactSeekableProgramDuration(\n  program: PibblAnimationProgram,\n): number | undefined {\n  if (exactSeekableDurations.has(program)) return exactSeekableDurations.get(program);\n  const record = getProgramRecord(program);\n  let duration: number | undefined;\n  if (record.kind === 'track') {\n    const definition = getDefinitionRecord(record.definition);\n    duration = definition.kind === 'stepper' ||\n      definition.kind === 'spring' && !definition.hasFrom ?\n      undefined : definition.duration;\n  } else if (record.kind === 'wait') {\n    duration = record.duration.kind === 'finite' ? record.duration.milliseconds : undefined;\n  } else if (record.kind === 'marker') {\n    duration = 0;\n  } else {\n    const childDurations = record.children.map(getExactSeekableProgramDuration);\n    if (childDurations.some(childDuration => childDuration === undefined)) {\n      duration = undefined;\n    } else if (record.kind === 'sequence') {\n      duration = (childDurations as number[]).reduce<number>((total, childDuration) =>\n        total + childDuration, 0);\n    } else if (record.kind === 'parallel') {\n      duration = Math.max(0, ...(childDurations as number[]));\n    } else {\n      const childDuration = childDurations[0] as number;\n      duration = record.iterations === Number.POSITIVE_INFINITY ?\n        Number.POSITIVE_INFINITY : childDuration * record.iterations;\n    }\n  }\n  exactSeekableDurations.set(program, duration);\n  return duration;\n}\n\nfunction resolvedSchedule(schedule: ResolvedWriterSchedule): WriterSchedule {\n  return freezeSchedule(\n    freezeSpan(schedule.output, schedule.start, schedule.end, schedule.path),\n    schedule.repeats,\n  );\n}\n\n/** @internal Uses Task 3's bounded exact symbolic proof for resolved schedules. */\nexport function resolvedWriterSchedulesOverlap(\n  first: ResolvedWriterSchedule,\n  second: ResolvedWriterSchedule,\n): boolean {\n  return schedulesOverlap(resolvedSchedule(first), resolvedSchedule(second));\n}\n\n/** @internal Adds one normalized symbolic repeat frame without expansion. */\nexport function repeatResolvedWriterSchedules(\n  schedules: readonly ResolvedWriterSchedule[],\n  period: number,\n  iterations: number,\n): readonly ResolvedWriterSchedule[] {\n  return Object.freeze(withRepeat(\n    schedules.map(resolvedSchedule),\n    period,\n    iterations,\n  ).map(schedule => Object.freeze({\n    output: schedule.span.output,\n    start: schedule.span.start,\n    end: schedule.span.end,\n    path: freezePath(schedule.span.path),\n    repeats: schedule.repeats,\n  })));\n}\n\nfunction dependentWriterOutputs(\n  program: PibblAnimationProgram,\n): ReadonlySet<WritableSignal<unknown>> {\n  const cached = activationDependentWriterOutputs.get(program);\n  if (cached !== undefined) return cached;\n  const record = getProgramRecord(program);\n  const dependent = new Set<WritableSignal<unknown>>();\n  if (record.kind === 'track') {\n    const definition = getDefinitionRecord(record.definition);\n    if (definition.kind === 'spring' && !definition.hasFrom) {\n      dependent.add(record.output);\n    }\n  } else if (record.kind === 'sequence') {\n    let prefixDurationDependsOnActivation = false;\n    for (const child of record.children) {\n      for (const output of dependentWriterOutputs(child)) dependent.add(output);\n      if (prefixDurationDependsOnActivation) {\n        for (const output of getProgramRecord(child).outputs) dependent.add(output);\n      }\n      if (getExactSeekableProgramDuration(child) === undefined) {\n        prefixDurationDependsOnActivation = true;\n      }\n    }\n  } else {\n    for (const child of record.children) {\n      for (const output of dependentWriterOutputs(child)) dependent.add(output);\n    }\n    if (record.kind === 'repeat' &&\n      getExactSeekableProgramDuration(record.children[0]!) === undefined &&\n      (record.iterations > 1 || record.direction !== 'normal')) {\n      for (const output of record.outputs) dependent.add(output);\n    }\n  }\n  activationDependentWriterOutputs.set(program, dependent);\n  return dependent;\n}\n\nfunction requiresActivationWriterSafetyAt(program: PibblAnimationProgram): boolean {\n  const record = getProgramRecord(program);\n  if (record.kind === 'parallel') {\n    for (let firstIndex = 0; firstIndex < record.children.length; firstIndex++) {\n      for (let secondIndex = firstIndex + 1;\n        secondIndex < record.children.length;\n        secondIndex++) {\n        const first = record.children[firstIndex]!;\n        const second = record.children[secondIndex]!;\n        const secondOutputs = getProgramRecord(second).outputs;\n        const firstDependent = dependentWriterOutputs(first);\n        const secondDependent = dependentWriterOutputs(second);\n        if (getProgramRecord(first).outputs.some(candidate =>\n          secondOutputs.includes(candidate) &&\n          (firstDependent.has(candidate) || secondDependent.has(candidate)),\n        )) return true;\n      }\n    }\n  }\n  if (record.kind === 'repeat' && record.iterations > 1 &&\n    getExactSeekableProgramDuration(record.children[0]!) === undefined &&\n    record.outputs.length > 0) {\n    return true;\n  }\n  return record.children.some(requiresActivationWriterSafetyAt);\n}\n\n/**\n * @internal Reports whether activation-resolved duration can invalidate a\n * construction-time parallel or repeat writer proof. The evaluator performs\n * the exact resolved proof against its private activation snapshot.\n */\nexport function requiresProgramActivationWriterSafety(\n  program: PibblAnimationProgram,\n): boolean {\n  return requiresActivationWriterSafetyAt(program);\n}\n"],
+  "mappings": "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",
+  "names": ["repeat"]
+}

package/dist/lib/animation/spring.d.ts

@@ -0,0 +1,30 @@
+import type { PibblSpringOptions } from './types.js';
+export interface SpringDefinitionRecord {
+    readonly kind: 'spring';
+    readonly duration: number;
+    readonly debugName: string | undefined;
+    readonly hasFrom: boolean;
+    readonly from: number;
+    readonly to: number;
+    readonly mass: number;
+    readonly stiffness: number;
+    readonly damping: number;
+    readonly initialVelocity: number;
+    readonly restSpeed: number;
+    readonly restDelta: number;
+    readonly maxDuration: number;
+}
+export interface SpringSample {
+    readonly position: number;
+    readonly velocity: number;
+}
+type SpringWithoutDuration = Omit<SpringDefinitionRecord, 'duration'>;
+/** @internal Resolves a deterministic settlement duration in milliseconds. */
+export declare function resolveSpringDuration(record: SpringWithoutDuration): number;
+/** @internal Creates the fully normalized immutable spring definition record. */
+export declare function createSpringRecord(options: Readonly<PibblSpringOptions>): SpringDefinitionRecord;
+/** @internal Resolves an omitted start from a track's activation snapshot. */
+export declare function resolveSpringStart(record: SpringDefinitionRecord, initialValue: number): SpringDefinitionRecord;
+/** @internal Samples position and logical-units-per-second velocity analytically. */
+export declare function sampleSpring(record: SpringDefinitionRecord, seconds: number): SpringSample;
+export {};

package/dist/lib/animation/spring.js

@@ -0,0 +1,324 @@
+const DEFAULT_MASS = 1;
+const DEFAULT_STIFFNESS = 170;
+const DEFAULT_DAMPING = 26;
+const DEFAULT_INITIAL_VELOCITY = 0;
+const DEFAULT_REST_SPEED = 0.01;
+const DEFAULT_REST_DELTA = 1e-3;
+const DEFAULT_MAX_DURATION = 1e4;
+const CRITICAL_DAMPING_EPSILON = 1e-7;
+const DURATION_BISECTION_ITERATIONS = 64;
+const INITIAL_BRACKET_SECONDS = 1e-3;
+function definitionLabel(debugName) {
+  return debugName === void 0 ? "Pibbl spring definition" : `Pibbl spring definition "${debugName}"`;
+}
+function finite(value, property, debugName) {
+  if (!Number.isFinite(value)) {
+    throw new RangeError(`${definitionLabel(debugName)} ${property} must be finite.`);
+  }
+  return value;
+}
+function positive(value, property, debugName) {
+  finite(value, property, debugName);
+  if (value <= 0) {
+    throw new RangeError(`${definitionLabel(debugName)} ${property} must be positive.`);
+  }
+  return value;
+}
+function nonnegative(value, property, debugName) {
+  finite(value, property, debugName);
+  if (value < 0) {
+    throw new RangeError(`${definitionLabel(debugName)} ${property} must be nonnegative.`);
+  }
+  return value;
+}
+function defaulted(value, fallback) {
+  return value === void 0 ? fallback : value;
+}
+function normalizedSpring(options) {
+  const debugName = options.debugName;
+  const hasFrom = options.from !== void 0;
+  return {
+    kind: "spring",
+    debugName,
+    hasFrom,
+    from: finite(defaulted(options.from, 0), "from", debugName),
+    to: finite(options.to, "to", debugName),
+    mass: positive(defaulted(options.mass, DEFAULT_MASS), "mass", debugName),
+    stiffness: positive(
+      defaulted(options.stiffness, DEFAULT_STIFFNESS),
+      "stiffness",
+      debugName
+    ),
+    damping: nonnegative(
+      defaulted(options.damping, DEFAULT_DAMPING),
+      "damping",
+      debugName
+    ),
+    initialVelocity: finite(
+      defaulted(options.initialVelocity, DEFAULT_INITIAL_VELOCITY),
+      "initialVelocity",
+      debugName
+    ),
+    restSpeed: nonnegative(
+      defaulted(options.restSpeed, DEFAULT_REST_SPEED),
+      "restSpeed",
+      debugName
+    ),
+    restDelta: nonnegative(
+      defaulted(options.restDelta, DEFAULT_REST_DELTA),
+      "restDelta",
+      debugName
+    ),
+    maxDuration: positive(
+      defaulted(options.maxDuration, DEFAULT_MAX_DURATION),
+      "maxDuration",
+      debugName
+    )
+  };
+}
+function frequencies(record) {
+  const logMass = Math.log(record.mass);
+  const logStiffness = Math.log(record.stiffness);
+  const natural = Math.exp((logStiffness - logMass) / 2);
+  const dampingLog = record.damping === 0 ? Number.NEGATIVE_INFINITY : Math.log(record.damping);
+  const ratio = record.damping === 0 ? 0 : Math.exp(
+    dampingLog - Math.LN2 - logStiffness / 2 - logMass / 2
+  );
+  const decay = record.damping === 0 ? 0 : Math.exp(
+    dampingLog - Math.LN2 - logMass
+  );
+  if (!(natural > 0) || !Number.isFinite(natural) || !Number.isFinite(ratio) || !Number.isFinite(decay)) {
+    throw new RangeError(
+      `${definitionLabel(record.debugName)} parameters must produce finite representable frequencies.`
+    );
+  }
+  return { natural, ratio, decay };
+}
+function displacement(record) {
+  const value = record.from - record.to;
+  if (!Number.isFinite(value)) {
+    throw new RangeError(
+      `${definitionLabel(record.debugName)} displacement must be finite and representable.`
+    );
+  }
+  return value;
+}
+function assertRepresentable(record, ...values) {
+  if (values.some((value) => !Number.isFinite(value))) {
+    throw new RangeError(
+      `${definitionLabel(record.debugName)} parameters must produce finite representable coefficients.`
+    );
+  }
+}
+function underdampedTerms(record, natural, ratio, decay) {
+  const initialDisplacement = displacement(record);
+  const damped = natural * Math.sqrt((1 - ratio) * (1 + ratio));
+  const velocityCoefficient = record.initialVelocity + decay * initialDisplacement;
+  const maximumSeconds = record.maxDuration / 1e3;
+  if (!(damped > 0)) {
+    throw new RangeError(
+      `${definitionLabel(record.debugName)} parameters must produce finite representable coefficients.`
+    );
+  }
+  assertRepresentable(
+    record,
+    damped,
+    velocityCoefficient,
+    damped * maximumSeconds,
+    velocityCoefficient * maximumSeconds,
+    initialDisplacement * damped,
+    decay * velocityCoefficient * maximumSeconds,
+    Math.abs(record.to) + Math.abs(initialDisplacement) + Math.abs(velocityCoefficient * maximumSeconds)
+  );
+  return { displacement: initialDisplacement, damped, velocityCoefficient };
+}
+function criticalEnvelope(record, natural) {
+  const a = displacement(record);
+  const b = record.initialVelocity + natural * a;
+  const maximumSeconds = record.maxDuration / 1e3;
+  assertRepresentable(
+    record,
+    b,
+    b * maximumSeconds,
+    natural * a,
+    natural * b,
+    natural * b * maximumSeconds,
+    Math.abs(record.to) + Math.abs(a) + Math.abs(b * maximumSeconds)
+  );
+  const velocityA = b - natural * a;
+  const velocityB = -natural * b;
+  const displacementA = Math.abs(a);
+  const displacementB = Math.abs(b);
+  const speedA = Math.abs(velocityA);
+  const speedB = Math.abs(velocityB);
+  const peak = (constant, slope) => {
+    if (slope === 0 || !Number.isFinite(slope)) return 0;
+    return Math.max(0, (slope - natural * constant) / (natural * slope));
+  };
+  return {
+    lastPeakSeconds: Math.max(
+      peak(displacementA, displacementB),
+      peak(speedA, speedB)
+    ),
+    displacement: (seconds) => (displacementA + displacementB * seconds) * Math.exp(-natural * seconds),
+    velocity: (seconds) => (speedA + speedB * seconds) * Math.exp(-natural * seconds)
+  };
+}
+function underdampedEnvelope(record, natural, ratio, decay) {
+  const terms = underdampedTerms(record, natural, ratio, decay);
+  const a = terms.displacement;
+  const b = terms.velocityCoefficient / terms.damped;
+  const displacementAmplitude = Math.hypot(a, b);
+  const velocitySineCoefficient = terms.velocityCoefficient === 0 ? 0 : -a * terms.damped - decay / terms.damped * terms.velocityCoefficient;
+  const velocityAmplitude = Math.hypot(
+    record.initialVelocity,
+    velocitySineCoefficient
+  );
+  const conservative = (value) => Number.isFinite(value) ? value : Number.POSITIVE_INFINITY;
+  return {
+    lastPeakSeconds: 0,
+    displacement: (seconds) => conservative(displacementAmplitude * Math.exp(-decay * seconds)),
+    velocity: (seconds) => conservative(velocityAmplitude * Math.exp(-decay * seconds))
+  };
+}
+function overdampedTerms(record, natural, ratio, decay) {
+  const reciprocalRatio = 1 / ratio;
+  const rootOffsetRatio = Math.sqrt(
+    (1 - reciprocalRatio) * (1 + reciprocalRatio)
+  );
+  const rootSum = decay * (1 + rootOffsetRatio);
+  const firstRoot = -(natural / rootSum) * natural;
+  const secondRoot = -rootSum;
+  const initialDisplacement = displacement(record);
+  const firstCoefficient = (record.initialVelocity - secondRoot * initialDisplacement) / (firstRoot - secondRoot);
+  const secondCoefficient = initialDisplacement - firstCoefficient;
+  if (!(firstRoot < 0) || !(secondRoot < 0)) {
+    throw new RangeError(
+      `${definitionLabel(record.debugName)} parameters must produce finite representable coefficients.`
+    );
+  }
+  assertRepresentable(
+    record,
+    firstRoot,
+    secondRoot,
+    firstCoefficient,
+    secondCoefficient,
+    firstRoot * firstCoefficient,
+    secondRoot * secondCoefficient,
+    Math.abs(record.to) + Math.abs(firstCoefficient) + Math.abs(secondCoefficient)
+  );
+  return {
+    firstCoefficient,
+    firstRoot,
+    secondCoefficient,
+    secondRoot
+  };
+}
+function overdampedEnvelope(record, natural, ratio, decay) {
+  const terms = overdampedTerms(record, natural, ratio, decay);
+  return {
+    lastPeakSeconds: 0,
+    displacement: (seconds) => Math.abs(terms.firstCoefficient) * Math.exp(terms.firstRoot * seconds) + Math.abs(terms.secondCoefficient) * Math.exp(terms.secondRoot * seconds),
+    velocity: (seconds) => Math.abs(terms.firstRoot * terms.firstCoefficient) * Math.exp(terms.firstRoot * seconds) + Math.abs(terms.secondRoot * terms.secondCoefficient) * Math.exp(terms.secondRoot * seconds)
+  };
+}
+function springEnvelope(record) {
+  const { natural, ratio, decay } = frequencies(record);
+  if (Math.abs(ratio - 1) <= CRITICAL_DAMPING_EPSILON) {
+    return criticalEnvelope(record, natural);
+  }
+  return ratio < 1 ? underdampedEnvelope(record, natural, ratio, decay) : overdampedEnvelope(record, natural, ratio, decay);
+}
+function resolveSpringDuration(record) {
+  if (record.from === record.to && record.initialVelocity === 0) return 0;
+  const envelope = springEnvelope(record);
+  const maximumSeconds = record.maxDuration / 1e3;
+  const settled = (seconds) => envelope.displacement(seconds) <= record.restDelta && envelope.velocity(seconds) <= record.restSpeed;
+  let lower = Math.min(maximumSeconds, envelope.lastPeakSeconds);
+  if (!Number.isFinite(lower)) return record.maxDuration;
+  if (settled(lower)) return lower * 1e3;
+  let bracketSize = Math.max(INITIAL_BRACKET_SECONDS, lower);
+  let upper = lower;
+  while (upper < maximumSeconds) {
+    upper = Math.min(maximumSeconds, lower + bracketSize);
+    if (settled(upper)) break;
+    lower = upper;
+    bracketSize *= 2;
+  }
+  if (!settled(upper)) return record.maxDuration;
+  for (let iteration = 0; iteration < DURATION_BISECTION_ITERATIONS; iteration++) {
+    const middle = lower + (upper - lower) / 2;
+    if (settled(middle)) upper = middle;
+    else lower = middle;
+  }
+  return upper * 1e3;
+}
+function createSpringRecord(options) {
+  const normalized = normalizedSpring(options);
+  return Object.freeze({
+    ...normalized,
+    duration: normalized.hasFrom ? resolveSpringDuration(normalized) : normalized.maxDuration
+  });
+}
+function resolveSpringStart(record, initialValue) {
+  if (record.hasFrom) return record;
+  const resolved = {
+    ...record,
+    hasFrom: true,
+    from: finite(initialValue, "activation value", record.debugName)
+  };
+  return Object.freeze({
+    ...resolved,
+    duration: resolveSpringDuration(resolved)
+  });
+}
+function sampleSpring(record, seconds) {
+  finite(seconds, "sample time", record.debugName);
+  const time = Math.max(0, seconds);
+  if (time >= record.duration / 1e3) {
+    return Object.freeze({ position: record.to, velocity: 0 });
+  }
+  if (time === 0) {
+    return Object.freeze({
+      position: record.from,
+      velocity: record.initialVelocity
+    });
+  }
+  const initialDisplacement = displacement(record);
+  const { natural, ratio, decay: decayRate } = frequencies(record);
+  let offset;
+  let velocity;
+  if (Math.abs(ratio - 1) <= CRITICAL_DAMPING_EPSILON) {
+    const b = record.initialVelocity + natural * initialDisplacement;
+    const decay = Math.exp(-natural * time);
+    offset = (initialDisplacement + b * time) * decay;
+    velocity = (b - natural * (initialDisplacement + b * time)) * decay;
+  } else if (ratio < 1) {
+    const terms = underdampedTerms(record, natural, ratio, decayRate);
+    const angle = terms.damped * time;
+    const sine = Math.sin(angle);
+    const sineOverFrequency = angle === 0 ? time : time * sine / angle;
+    const decay = Math.exp(-decayRate * time);
+    const cosine = Math.cos(angle);
+    offset = decay * (initialDisplacement * cosine + terms.velocityCoefficient * sineOverFrequency);
+    velocity = decay * (record.initialVelocity * cosine - initialDisplacement * terms.damped * sine - decayRate * terms.velocityCoefficient * sineOverFrequency);
+  } else {
+    const terms = overdampedTerms(record, natural, ratio, decayRate);
+    const first = terms.firstCoefficient * Math.exp(terms.firstRoot * time);
+    const second = terms.secondCoefficient * Math.exp(terms.secondRoot * time);
+    offset = first + second;
+    velocity = terms.firstRoot * first + terms.secondRoot * second;
+  }
+  const position = record.to + offset;
+  if (!Number.isFinite(position) || !Number.isFinite(velocity)) {
+    throw new RangeError(`${definitionLabel(record.debugName)} sampled values must be finite.`);
+  }
+  return Object.freeze({ position, velocity });
+}
+export {
+  createSpringRecord,
+  resolveSpringDuration,
+  resolveSpringStart,
+  sampleSpring
+};
+//# sourceMappingURL=spring.js.map

package/dist/lib/animation/spring.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/animation/spring.ts"],
+  "sourcesContent": ["import type { PibblSpringOptions } from './types.js';\n\nconst DEFAULT_MASS = 1;\nconst DEFAULT_STIFFNESS = 170;\nconst DEFAULT_DAMPING = 26;\nconst DEFAULT_INITIAL_VELOCITY = 0;\nconst DEFAULT_REST_SPEED = 0.01;\nconst DEFAULT_REST_DELTA = 0.001;\nconst DEFAULT_MAX_DURATION = 10_000;\n\n/**\n * Ratios this close to one use the critical solution. This avoids dividing by\n * a vanishing damped frequency or root separation without changing visibly\n * distinct underdamped and overdamped springs.\n */\nconst CRITICAL_DAMPING_EPSILON = 1e-7;\nconst DURATION_BISECTION_ITERATIONS = 64;\nconst INITIAL_BRACKET_SECONDS = 0.001;\n\nexport interface SpringDefinitionRecord {\n  readonly kind: 'spring';\n  readonly duration: number;\n  readonly debugName: string | undefined;\n  readonly hasFrom: boolean;\n  readonly from: number;\n  readonly to: number;\n  readonly mass: number;\n  readonly stiffness: number;\n  readonly damping: number;\n  readonly initialVelocity: number;\n  readonly restSpeed: number;\n  readonly restDelta: number;\n  readonly maxDuration: number;\n}\n\nexport interface SpringSample {\n  readonly position: number;\n  readonly velocity: number;\n}\n\ntype SpringWithoutDuration = Omit<SpringDefinitionRecord, 'duration'>;\n\ninterface SpringEnvelope {\n  readonly lastPeakSeconds: number;\n  readonly displacement: (seconds: number) => number;\n  readonly velocity: (seconds: number) => number;\n}\n\ninterface SpringFrequencies {\n  readonly natural: number;\n  readonly ratio: number;\n  readonly decay: number;\n}\n\nfunction definitionLabel(debugName: string | undefined): string {\n  return debugName === undefined ? 'Pibbl spring definition' :\n    `Pibbl spring definition \"${debugName}\"`;\n}\n\nfunction finite(value: number, property: string, debugName: string | undefined): number {\n  if (!Number.isFinite(value)) {\n    throw new RangeError(`${definitionLabel(debugName)} ${property} must be finite.`);\n  }\n  return value;\n}\n\nfunction positive(value: number, property: string, debugName: string | undefined): number {\n  finite(value, property, debugName);\n  if (value <= 0) {\n    throw new RangeError(`${definitionLabel(debugName)} ${property} must be positive.`);\n  }\n  return value;\n}\n\nfunction nonnegative(\n  value: number,\n  property: string,\n  debugName: string | undefined,\n): number {\n  finite(value, property, debugName);\n  if (value < 0) {\n    throw new RangeError(`${definitionLabel(debugName)} ${property} must be nonnegative.`);\n  }\n  return value;\n}\n\nfunction defaulted(value: number | undefined, fallback: number): number {\n  return value === undefined ? fallback : value;\n}\n\nfunction normalizedSpring(options: Readonly<PibblSpringOptions>): SpringWithoutDuration {\n  const debugName = options.debugName;\n  const hasFrom = options.from !== undefined;\n  return {\n    kind: 'spring',\n    debugName,\n    hasFrom,\n    from: finite(defaulted(options.from, 0), 'from', debugName),\n    to: finite(options.to, 'to', debugName),\n    mass: positive(defaulted(options.mass, DEFAULT_MASS), 'mass', debugName),\n    stiffness: positive(\n      defaulted(options.stiffness, DEFAULT_STIFFNESS),\n      'stiffness',\n      debugName,\n    ),\n    damping: nonnegative(\n      defaulted(options.damping, DEFAULT_DAMPING),\n      'damping',\n      debugName,\n    ),\n    initialVelocity: finite(\n      defaulted(options.initialVelocity, DEFAULT_INITIAL_VELOCITY),\n      'initialVelocity',\n      debugName,\n    ),\n    restSpeed: nonnegative(\n      defaulted(options.restSpeed, DEFAULT_REST_SPEED),\n      'restSpeed',\n      debugName,\n    ),\n    restDelta: nonnegative(\n      defaulted(options.restDelta, DEFAULT_REST_DELTA),\n      'restDelta',\n      debugName,\n    ),\n    maxDuration: positive(\n      defaulted(options.maxDuration, DEFAULT_MAX_DURATION),\n      'maxDuration',\n      debugName,\n    ),\n  };\n}\n\nfunction frequencies(record: SpringWithoutDuration): SpringFrequencies {\n  const logMass = Math.log(record.mass);\n  const logStiffness = Math.log(record.stiffness);\n  const natural = Math.exp((logStiffness - logMass) / 2);\n  const dampingLog = record.damping === 0 ? Number.NEGATIVE_INFINITY :\n    Math.log(record.damping);\n  const ratio = record.damping === 0 ? 0 : Math.exp(\n    dampingLog - Math.LN2 - logStiffness / 2 - logMass / 2,\n  );\n  const decay = record.damping === 0 ? 0 : Math.exp(\n    dampingLog - Math.LN2 - logMass,\n  );\n  if (!(natural > 0) || !Number.isFinite(natural) ||\n    !Number.isFinite(ratio) || !Number.isFinite(decay)) {\n    throw new RangeError(\n      `${definitionLabel(record.debugName)} parameters must produce finite representable frequencies.`,\n    );\n  }\n  return { natural, ratio, decay };\n}\n\nfunction displacement(record: SpringWithoutDuration): number {\n  const value = record.from - record.to;\n  if (!Number.isFinite(value)) {\n    throw new RangeError(\n      `${definitionLabel(record.debugName)} displacement must be finite and representable.`,\n    );\n  }\n  return value;\n}\n\nfunction assertRepresentable(\n  record: SpringWithoutDuration,\n  ...values: readonly number[]\n): void {\n  if (values.some(value => !Number.isFinite(value))) {\n    throw new RangeError(\n      `${definitionLabel(record.debugName)} parameters must produce finite representable coefficients.`,\n    );\n  }\n}\n\nfunction underdampedTerms(\n  record: SpringWithoutDuration,\n  natural: number,\n  ratio: number,\n  decay: number,\n): {\n  readonly displacement: number;\n  readonly damped: number;\n  readonly velocityCoefficient: number;\n} {\n  const initialDisplacement = displacement(record);\n  const damped = natural * Math.sqrt((1 - ratio) * (1 + ratio));\n  const velocityCoefficient =\n    record.initialVelocity + decay * initialDisplacement;\n  const maximumSeconds = record.maxDuration / 1000;\n  if (!(damped > 0)) {\n    throw new RangeError(\n      `${definitionLabel(record.debugName)} parameters must produce finite representable coefficients.`,\n    );\n  }\n  assertRepresentable(\n    record,\n    damped,\n    velocityCoefficient,\n    damped * maximumSeconds,\n    velocityCoefficient * maximumSeconds,\n    initialDisplacement * damped,\n    decay * velocityCoefficient * maximumSeconds,\n    Math.abs(record.to) + Math.abs(initialDisplacement) +\n      Math.abs(velocityCoefficient * maximumSeconds),\n  );\n  return { displacement: initialDisplacement, damped, velocityCoefficient };\n}\n\nfunction criticalEnvelope(\n  record: SpringWithoutDuration,\n  natural: number,\n): SpringEnvelope {\n  const a = displacement(record);\n  const b = record.initialVelocity + natural * a;\n  const maximumSeconds = record.maxDuration / 1000;\n  assertRepresentable(\n    record,\n    b,\n    b * maximumSeconds,\n    natural * a,\n    natural * b,\n    natural * b * maximumSeconds,\n    Math.abs(record.to) + Math.abs(a) + Math.abs(b * maximumSeconds),\n  );\n  const velocityA = b - natural * a;\n  const velocityB = -natural * b;\n  const displacementA = Math.abs(a);\n  const displacementB = Math.abs(b);\n  const speedA = Math.abs(velocityA);\n  const speedB = Math.abs(velocityB);\n  const peak = (constant: number, slope: number): number => {\n    if (slope === 0 || !Number.isFinite(slope)) return 0;\n    return Math.max(0, (slope - natural * constant) / (natural * slope));\n  };\n  return {\n    lastPeakSeconds: Math.max(\n      peak(displacementA, displacementB),\n      peak(speedA, speedB),\n    ),\n    displacement: seconds =>\n      (displacementA + displacementB * seconds) * Math.exp(-natural * seconds),\n    velocity: seconds =>\n      (speedA + speedB * seconds) * Math.exp(-natural * seconds),\n  };\n}\n\nfunction underdampedEnvelope(\n  record: SpringWithoutDuration,\n  natural: number,\n  ratio: number,\n  decay: number,\n): SpringEnvelope {\n  const terms = underdampedTerms(record, natural, ratio, decay);\n  const a = terms.displacement;\n  const b = terms.velocityCoefficient / terms.damped;\n  const displacementAmplitude = Math.hypot(a, b);\n  const velocitySineCoefficient = terms.velocityCoefficient === 0 ? 0 :\n    -a * terms.damped - (decay / terms.damped) * terms.velocityCoefficient;\n  const velocityAmplitude = Math.hypot(\n    record.initialVelocity,\n    velocitySineCoefficient,\n  );\n  const conservative = (value: number): number =>\n    Number.isFinite(value) ? value : Number.POSITIVE_INFINITY;\n  return {\n    lastPeakSeconds: 0,\n    displacement: seconds =>\n      conservative(displacementAmplitude * Math.exp(-decay * seconds)),\n    velocity: seconds =>\n      conservative(velocityAmplitude * Math.exp(-decay * seconds)),\n  };\n}\n\nfunction overdampedTerms(\n  record: SpringWithoutDuration,\n  natural: number,\n  ratio: number,\n  decay: number,\n): {\n  readonly firstCoefficient: number;\n  readonly firstRoot: number;\n  readonly secondCoefficient: number;\n  readonly secondRoot: number;\n} {\n  const reciprocalRatio = 1 / ratio;\n  const rootOffsetRatio = Math.sqrt(\n    (1 - reciprocalRatio) * (1 + reciprocalRatio),\n  );\n  const rootSum = decay * (1 + rootOffsetRatio);\n  const firstRoot = -(natural / rootSum) * natural;\n  const secondRoot = -rootSum;\n  const initialDisplacement = displacement(record);\n  const firstCoefficient =\n    (record.initialVelocity - secondRoot * initialDisplacement) /\n    (firstRoot - secondRoot);\n  const secondCoefficient = initialDisplacement - firstCoefficient;\n  if (!(firstRoot < 0) || !(secondRoot < 0)) {\n    throw new RangeError(\n      `${definitionLabel(record.debugName)} parameters must produce finite representable coefficients.`,\n    );\n  }\n  assertRepresentable(\n    record,\n    firstRoot,\n    secondRoot,\n    firstCoefficient,\n    secondCoefficient,\n    firstRoot * firstCoefficient,\n    secondRoot * secondCoefficient,\n    Math.abs(record.to) + Math.abs(firstCoefficient) + Math.abs(secondCoefficient),\n  );\n  return {\n    firstCoefficient,\n    firstRoot,\n    secondCoefficient,\n    secondRoot,\n  };\n}\n\nfunction overdampedEnvelope(\n  record: SpringWithoutDuration,\n  natural: number,\n  ratio: number,\n  decay: number,\n): SpringEnvelope {\n  const terms = overdampedTerms(record, natural, ratio, decay);\n  return {\n    lastPeakSeconds: 0,\n    displacement: seconds =>\n      Math.abs(terms.firstCoefficient) * Math.exp(terms.firstRoot * seconds) +\n      Math.abs(terms.secondCoefficient) * Math.exp(terms.secondRoot * seconds),\n    velocity: seconds =>\n      Math.abs(terms.firstRoot * terms.firstCoefficient) *\n        Math.exp(terms.firstRoot * seconds) +\n      Math.abs(terms.secondRoot * terms.secondCoefficient) *\n        Math.exp(terms.secondRoot * seconds),\n  };\n}\n\nfunction springEnvelope(record: SpringWithoutDuration): SpringEnvelope {\n  const { natural, ratio, decay } = frequencies(record);\n  if (Math.abs(ratio - 1) <= CRITICAL_DAMPING_EPSILON) {\n    return criticalEnvelope(record, natural);\n  }\n  return ratio < 1 ?\n    underdampedEnvelope(record, natural, ratio, decay) :\n    overdampedEnvelope(record, natural, ratio, decay);\n}\n\n/** @internal Resolves a deterministic settlement duration in milliseconds. */\nexport function resolveSpringDuration(record: SpringWithoutDuration): number {\n  if (record.from === record.to && record.initialVelocity === 0) return 0;\n  const envelope = springEnvelope(record);\n  const maximumSeconds = record.maxDuration / 1000;\n  const settled = (seconds: number): boolean =>\n    envelope.displacement(seconds) <= record.restDelta &&\n    envelope.velocity(seconds) <= record.restSpeed;\n\n  let lower = Math.min(maximumSeconds, envelope.lastPeakSeconds);\n  if (!Number.isFinite(lower)) return record.maxDuration;\n  if (settled(lower)) return lower * 1000;\n\n  let bracketSize = Math.max(INITIAL_BRACKET_SECONDS, lower);\n  let upper = lower;\n  while (upper < maximumSeconds) {\n    upper = Math.min(maximumSeconds, lower + bracketSize);\n    if (settled(upper)) break;\n    lower = upper;\n    bracketSize *= 2;\n  }\n  if (!settled(upper)) return record.maxDuration;\n\n  for (let iteration = 0; iteration < DURATION_BISECTION_ITERATIONS; iteration++) {\n    const middle = lower + (upper - lower) / 2;\n    if (settled(middle)) upper = middle;\n    else lower = middle;\n  }\n  return upper * 1000;\n}\n\n/** @internal Creates the fully normalized immutable spring definition record. */\nexport function createSpringRecord(\n  options: Readonly<PibblSpringOptions>,\n): SpringDefinitionRecord {\n  const normalized = normalizedSpring(options);\n  return Object.freeze({\n    ...normalized,\n    duration: normalized.hasFrom ?\n      resolveSpringDuration(normalized) : normalized.maxDuration,\n  });\n}\n\n/** @internal Resolves an omitted start from a track's activation snapshot. */\nexport function resolveSpringStart(\n  record: SpringDefinitionRecord,\n  initialValue: number,\n): SpringDefinitionRecord {\n  if (record.hasFrom) return record;\n  const resolved = {\n    ...record,\n    hasFrom: true,\n    from: finite(initialValue, 'activation value', record.debugName),\n  };\n  return Object.freeze({\n    ...resolved,\n    duration: resolveSpringDuration(resolved),\n  });\n}\n\n/** @internal Samples position and logical-units-per-second velocity analytically. */\nexport function sampleSpring(\n  record: SpringDefinitionRecord,\n  seconds: number,\n): SpringSample {\n  finite(seconds, 'sample time', record.debugName);\n  const time = Math.max(0, seconds);\n  if (time >= record.duration / 1000) {\n    return Object.freeze({ position: record.to, velocity: 0 });\n  }\n  if (time === 0) {\n    return Object.freeze({\n      position: record.from,\n      velocity: record.initialVelocity,\n    });\n  }\n\n  const initialDisplacement = displacement(record);\n  const { natural, ratio, decay: decayRate } = frequencies(record);\n  let offset: number;\n  let velocity: number;\n  if (Math.abs(ratio - 1) <= CRITICAL_DAMPING_EPSILON) {\n    const b = record.initialVelocity + natural * initialDisplacement;\n    const decay = Math.exp(-natural * time);\n    offset = (initialDisplacement + b * time) * decay;\n    velocity = (b - natural * (initialDisplacement + b * time)) * decay;\n  } else if (ratio < 1) {\n    const terms = underdampedTerms(record, natural, ratio, decayRate);\n    const angle = terms.damped * time;\n    const sine = Math.sin(angle);\n    const sineOverFrequency = angle === 0 ? time : time * sine / angle;\n    const decay = Math.exp(-decayRate * time);\n    const cosine = Math.cos(angle);\n    offset = decay * (\n      initialDisplacement * cosine +\n      terms.velocityCoefficient * sineOverFrequency\n    );\n    velocity = decay * (\n      record.initialVelocity * cosine -\n      initialDisplacement * terms.damped * sine -\n      decayRate * terms.velocityCoefficient * sineOverFrequency\n    );\n  } else {\n    const terms = overdampedTerms(record, natural, ratio, decayRate);\n    const first = terms.firstCoefficient * Math.exp(terms.firstRoot * time);\n    const second = terms.secondCoefficient * Math.exp(terms.secondRoot * time);\n    offset = first + second;\n    velocity = terms.firstRoot * first + terms.secondRoot * second;\n  }\n\n  const position = record.to + offset;\n  if (!Number.isFinite(position) || !Number.isFinite(velocity)) {\n    throw new RangeError(`${definitionLabel(record.debugName)} sampled values must be finite.`);\n  }\n  return Object.freeze({ position, velocity });\n}\n"],
+  "mappings": "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",
+  "names": []
+}