```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 into a dotted form with exactly two fraction digits.
 * @param cents - The integer cents to format.
 * @returns The formatted 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 baseShares = weights.map(weight => Math.floor((weight / totalWeight) * totalCents));
  let remainingCents = totalCents - baseShares.reduce((sum, share) => sum + share, 0);
  const remainderIndices = weights
    .map((weight, index) => ({ weight, index }))
    .sort((a, b) => (b.weight % totalWeight - a.weight % totalWeight) || a.index - b.index)
    .map(item => item.index);

  for (const index of remainderIndices) {
    if (remainingCents > 0) {
      baseShares[index]++;
      remainingCents--;
    }
  }

  return baseShares;
}
```