interface PipelineConfig {
  timeout: number;
  retries: number;
  metadata: { region: string; version: string };
}

const baseConfig: PipelineConfig = {
  timeout: 5000,
  retries: 2,
  metadata: { region: "us-east-1", version: "v1" }
};

// Safe flat expansion
const runtimeConfig: PipelineConfig = {
  ...baseConfig,
  timeout: 10000,
  metadata: { ...baseConfig.metadata, version: "v2" }
};

type LogFn = (level: string, ...entries: unknown[]) =>

void;

const structuredLogger: LogFn = (level, ...entries) => { const timestamp = new Date().toISOString(); entries.forEach((entry, index) => { console.log([${timestamp}] ${level.toUpperCase()} [${index + 1}]:, entry); }); };

structuredLogger("warn", "Connection pool low", { active: 3, max: 10 });

**Architecture Rationale**: Using `unknown[]` instead of `any[]` enforces type narrowing at the call site. The rest parameter guarantees a real array, enabling direct use of `Array.prototype` methods without conversion.

### Step 4: TypeScript Integration
Spread and rest interact with TypeScript's type inference differently. Spread preserves literal types when possible. Rest infers tuple-to-array widening.

```typescript
interface FeatureFlags {
  darkMode: boolean;
  betaAccess: boolean;
}

const defaultFlags: FeatureFlags = { darkMode: false, betaAccess: false };
const userFlags: Partial<FeatureFlags> = { darkMode: true };

const mergedFlags: FeatureFlags = { ...defaultFlags, ...userFlags };
// Type: { darkMode: boolean; betaAccess: boolean }

Architecture Rationale: Partial<T> allows safe overrides without violating the target interface. The spread operation maintains structural typing, and the compiler validates property compatibility at compile time.

Pitfall Guide

1. Shallow Copy Illusion

Explanation: Spread only copies the first level of an object or array. Nested references remain shared. Mutating a nested property affects all copies. Fix: Explicitly spread nested structures or use structuredClone() for deep immutability. Reserve spread for flat data or controlled depth overrides.

2. Rest Parameter Positioning Violation

Explanation: Rest parameters must be the final item in a function signature. Placing them before named parameters causes a syntax error. Fix: Always position ...args at the end. If you need to extract specific arguments first, destructure them before the rest parameter or use tuple types.

3. Object Spread Ignores Prototype Chain

Explanation: Spread only copies own enumerable properties. Methods attached to the prototype are not transferred. Fix: Use Object.assign() or class instantiation when prototype methods must be preserved. Spread is strictly for plain data objects.

4. Iterables vs Objects Mismatch

Explanation: Spread works on iterables (arrays, strings, maps, sets). Rest works on arrays and objects in destructuring. Spreading a non-iterable throws a TypeError. Fix: Validate data shape before spreading. Use Array.from() or Object.values() to convert non-iterables when necessary.

5. Performance Overhead in Tight Loops

Explanation: Spreading inside a loop creates new allocations on every iteration, triggering garbage collection pressure. Fix: Pre-allocate arrays or use Array.prototype.push() with spread once. Avoid [...acc, newItem] in reduce() for large datasets.

6. TypeScript Generic Constraint Omission

Explanation: Using ...args: T[] without proper constraints allows invalid types to pass through, breaking type safety. Fix: Constrain generics with extends or use union types. Example: function merge<T extends Record<string, unknown>>(...sources: T[]): T

7. Mixing Spread and Rest in Same Expression

Explanation: Attempting to spread and rest in the same destructuring or literal context causes parsing ambiguity. Fix: Separate concerns. Use spread for merging, rest for extraction. Never combine them in a single pattern without clear boundary separation.

Production Bundle

Action Checklist

• Verify lexical position: right-side/call = spread, left-side/parameter = rest
• Audit nested objects for shallow copy risks; explicitly spread or use structuredClone()
• Ensure rest parameters are always last in function signatures
• Replace Object.assign() with spread for plain object merging unless prototype preservation is required
• Validate iterables before spreading; convert non-iterables explicitly
• Avoid spread in tight loops; pre-allocate or batch operations
• Apply TypeScript constraints to generic rest/spread utilities
• Test state mutations in React/Redux pipelines with spread-based reducers

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Flat config merging	Spread ({...a, ...b})	Readable, engine-optimized, type-safe	Low (memory allocation per layer)
Deep state updates	structuredClone() or immutable libraries	Prevents nested reference sharing	Medium (CPU overhead for deep traversal)
Variadic function args	Rest (...args: T[])	Guarantees real array, enables array methods	Low (single allocation)
Prototype method preservation	Object.assign() or class instantiation	Spread ignores prototype chain	Low (negligible difference)
Large dataset deduplication	Set + spread ([...new Set(arr)])	O(n) deduplication, clean syntax	Medium (Set allocation + spread copy)

Configuration Template

// safe-merge.ts
type PlainObject = Record<string, unknown>;

export function safeMerge<T extends PlainObject>(
  base: T,
  override: Partial<T>
): T {
  const merged = { ...base, ...override } as T;
  
  // Validate no prototype pollution
  if (Object.getPrototypeOf(merged) !== Object.prototype) {
    throw new Error("Prototype chain detected in merge target");
  }
  
  return merged;
}

// variadic-handler.ts
export function createVariadicLogger<T extends unknown[]>(
  prefix: string,
  handler: (...items: T) => void
) {
  return (...args: T) => {
    console.log(`[${prefix}]`);
    handler(...args);
  };
}

Quick Start Guide

1. Identify Context: Locate ... in your code. If it's in an expression or function call, treat it as spread. If it's in a parameter list or destructuring target, treat it as rest.
2. Apply Shallow Copy Rules: Use spread for flat objects/arrays. For nested data, explicitly spread inner layers or switch to structuredClone().
3. Type with Constraints: Add TypeScript generics with extends to prevent type leakage. Use Partial<T> for safe overrides.
4. Validate Iterables: Before spreading, confirm the value implements Symbol.iterator. Convert maps/sets/strings explicitly if needed.
5. Benchmark Loops: Replace [...acc, item] in iterations with pre-allocated arrays or Array.prototype.push(). Measure allocation frequency with Chrome DevTools Memory panel.