```ts
/**
 * Simulates a factory line with processing stations in series and holding buffers between them.
 * @param capacities - An array of per-tick piece limits for each station.
 * @param buffers - An array of buffer sizes between each pair of stations.
 * @param ticks - The number of whole ticks to simulate.
 * @returns An object with keys "made" (pieces the last station finished) and "left" (final content of each buffer).
 */
export function runBufferedLine(capacities: number[], buffers: number[], ticks: number): { made: number; left: number[] } {
  if (capacities.length === 0) {
    throw new Error("Station list cannot be empty.");
  }
  if (buffers.length !== capacities.length - 1) {
    throw new Error("Buffer list must have exactly one entry fewer than the station list.");
  }
  if (!capacities.every(limit => Number.isPositiveInteger(limit))) {
    throw new Error("All per-tick limits must be positive integers.");
  }
  if (!buffers.every(size => Number.isPositiveInteger(size))) {
    throw new Error("All buffer sizes must be positive integers.");
  }
  if (!Number.isNonNegativeInteger(ticks)) {
    throw new Error("Tick count must be a non-negative integer.");
  }

  const numBuffers = buffers.length;
  let made = 0;
  const bufferContents = new Array(numBuffers).fill(0);

  for (let tick = 0; tick < ticks; tick++) {
    for (let stationIndex = capacities.length - 1; stationIndex > 0; stationIndex--) {
      const capacity = capacities[stationIndex];
      const bufferSize = buffers[stationIndex - 1];
      const inboundBuffer = bufferContents[stationIndex - 1];
      const outboundBufferFreeSpace = bufferSize - bufferContents[stationIndex];

      const piecesToMove = Math.min(capacity, inboundBuffer, outboundBufferFreeSpace);
      bufferContents[stationIndex] += piecesToMove;
      bufferContents[stationIndex - 1] -= piecesToMove;
    }

    // First station draws from unlimited stock
    const firstStationCapacity = capacities[0];
    const firstOutboundBufferFreeSpace = buffers[0] - bufferContents[0];
    const piecesToProduce = Math.min(firstStationCapacity, firstOutboundBufferFreeSpace);
    bufferContents[0] += piecesToProduce;
  }

  made = bufferContents[numBuffers - 1];
  return { made, left: bufferContents };
}
```