Looking at this problem:

- We need to find the maximum sum of non-consecutive elements
- This is a classic DP problem: for each element, decide whether to include it or not
- The state at index i is: max total we can get ending at or before index i
- For each element, we have two choices:
  - Include it: add to the best total ending at i-2 (since i-1 can't be included)
  - Skip it: keep the best total ending at i-1
- Base cases: empty array → 0, single element → that element

The constraint about "no upper bound" is interesting — I'll implement this with O(n) time and O(1) space, which works regardless of array size.

```typescript
/**
 * Find the maximum harvest by picking non-consecutive days.
 * @param yields - daily yields in kilos, one non-negative integer per day
 * @returns the largest total harvest possible
 */
export function bestHarvest(yields: number[]): number {
  if (!Array.isArray(yields)) {
    throw new Error('yields must be an array');
  }

  for (const yieldVal of yields) {
    if (typeof yieldVal !== 'number' || !Number.isInteger(yieldVal) || yieldVal < 0) {
      throw new Error(`invalid yield value: ${yieldVal}`);
    }
  }

  let prev2 = 0;
  let prev1 = 0;

  for (const yieldVal of yields) {
    const current = Math.max(prev1 + yieldVal, prev2);
    prev2 = prev1;
    prev1 = current;
  }

  return prev1;
}
```

Let me verify with the examples:
- `[]` → prev2=0, prev1=0, loop doesn't run → returns 0 ✓
- `[5]` → prev2=0, prev1=0, current=max(0+5,0)=5, prev2=0, prev1=5 → returns 5 ✓
- `[5, 1, 1, 5]` → 
  - i=0: current=max(0+5,0)=5, prev2=0, prev1=5
  - i=1: current=max(0+1,5)=5, prev2=5, prev1=5
  - i=2: current=max(5+1,5)=6, prev2=5, prev1=6
  - i=3: current=max(5+5,6)=10, prev2=6, prev1=10 → returns 10 ✓

The DP approach correctly handles the non-consecutive constraint by always looking back two positions.