```ts
/**
 * Parses a decimal amount string into integer cents.
 * @param text - The decimal amount string to parse.
 * @returns The parsed integer cents.
 */
export function parseAmount(text: string): number {
  if (typeof text !== 'string') {
    throw new Error('Input must be a string');
  }
  const match = text.match(/^\d+(\.\d{2})?$/);
  if (!match) {
    throw new Error('Invalid amount format');
  }
  return Math.round(parseFloat(text) * 100);
}

/**
 * Formats non-negative integer cents back into a dotted form with exactly two fraction digits.
 * @param cents - The integer cents to format.
 * @returns The formatted decimal amount string.
 */
export function formatAmount(cents: number): string {
  if (typeof cents !== 'number' || cents < 0 || !Number.isInteger(cents)) {
    throw new Error('Input must be a non-negative integer');
  }
  return cents.toFixed(2);
}

/**
 * Allocates totalCents across a list of integer weights proportionally.
 * @param totalCents - The total integer cents to allocate.
 * @param weights - The list of integer weights to allocate the cents to.
 * @returns An array of allocated integer cents for each weight.
 */
export function allocateCents(totalCents: number, weights: number[]): number[] {
  if (!Array.isArray(weights) || weights.length === 0) {
    throw new Error('Weights list must not be empty');
  }
  if (weights.some(weight => typeof weight !== 'number' || weight < 0 || !Number.isInteger(weight))) {
    throw new Error('All weights must be non-negative integers');
  }
  if (totalCents < 0 || !Number.isInteger(totalCents)) {
    throw new Error('Total cents must be a non-negative integer');
  }
  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
  if (totalWeight === 0) {
    throw new Error('Weights must not sum to zero');
  }

  const baseAllocation = Math.floor(totalCents / totalWeight);
  const remainder = totalCents % totalWeight;
  const allocations = weights.map(weight => baseAllocation * weight);

  for (let i = 0; i < remainder; i++) {
    allocations[i]++;
  }

  return allocations;
}
```