Prompt Engineering
Send Large Project Context — Code and Docs in One Package

Project context is mixed: code, notes, and docs together. Send it as one sequenced package the model holds complete before any work begins.
Overview

Real project context rarely arrives as one clean document — it is source files, design notes, and explanations interleaved. The package handles the mix: fences keep the code atomic, paragraphs carry the prose, file markers label the sources, and AI Reading Mode holds the model silent until the whole bundle has landed. The payoff is a conversation that starts from complete context instead of accumulating it across ad-hoc pastes — every later question in the session draws on the same fully-delivered foundation. This setup loads a code-plus-commentary project bundle in strict reading mode.
Workflow

Bundle, don't trickle
One ordered package beats fifteen ad-hoc pastes the model half-remembers.
Mixed content, kept apart
Fences stay atomic, prose stays paragraphed, files stay labeled — the mix survives.
Start work from complete
Reading mode holds the model until everything has arrived; the session begins fully loaded.
Why This Works

Complete-before-work beats context accumulated mid-conversation
Type-aware handling keeps mixed bundles coherent
One package gives every later question the same foundation
Best for

Session setup for substantial project work
Mixed-content bundles that defeat single-type tools
Pairing sessions that need shared complete context
Not for

Context the AI should know across ALL future sessions — that's the Project Context Builder's territory
Bundles that exceed the whole window — the feasibility warning routes to the Handoff Builder
Use cases

Loading a project's context at the start of a session
Sending code with its design notes attached
Replacing ad-hoc pastes with one ordered delivery
Customize This Resource

Opens this scenario in Long Prompt Splitter. Split to get the full chunked package — then adjust the chunk size and delivery mode.
Open in Long Prompt Splitter
Prompt Template

CHUNKED CONTEXT PACKAGE

DELIVERY INSTRUCTIONS
- Send each chunk below as ONE message, in order, starting with Chunk 1.
- Wait for the model's acknowledgement ("Received chunk i of 4") before sending the next chunk.
- Do not edit the chunk contents — the markers and the content are designed to travel together.

CHUNK STRATEGY
- Content: 25,168 characters, ~6,992–8,989 tokens (Code).
- Target model: Claude Sonnet (200,000-token window; verified June 2026).
- Chunk budget: ~4,000 tokens (11,200 characters max per chunk) → 4 chunks.
- Delivery mode: AI Reading Mode — Strict reading mode — the model is told to wait for every part and is forbidden from early analysis.
- Boundary quality: 3 section breaks, 0 paragraph breaks, 0 line-level breaks, 0 hard cuts.

===== CHUNK 1 of 4 =====
- This content arrives in 4 parts. The parts form ONE continuous document, in order.
- Do NOT respond, summarize, or analyze yet — not after this part, and not after any part except the final one.
- Wait until the final part explicitly announces that all chunks are delivered.
- After reading, reply ONLY: "Received chunk 1 of 4." Then wait for the next chunk.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.


----- END OF CHUNK 1 of 4 — do not respond yet; chunk 2 follows -----

===== CHUNK 2 of 4 =====
- Chunk 2 of 4 — part of the same continuous content. The earlier rules still apply.
- After reading, reply ONLY: "Received chunk 2 of 4." Then wait for the next chunk.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.


----- END OF CHUNK 2 of 4 — do not respond yet; chunk 3 follows -----

===== CHUNK 3 of 4 =====
- Chunk 3 of 4 — part of the same continuous content. The earlier rules still apply.
- After reading, reply ONLY: "Received chunk 3 of 4." Then wait for the next chunk.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.


----- END OF CHUNK 3 of 4 — do not respond yet; chunk 4 follows -----

===== CHUNK 4 of 4 =====
- Chunk 4 of 4 — part of the same continuous content. The earlier rules still apply.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

===== ALL 4 CHUNKS DELIVERED =====
- All 4 chunks are delivered — the waiting rule ends now.
- Respond using the COMPLETE content across all chunks; do not answer from the final chunk alone.

TASK
[Describe what the AI should do with the full content]

NOTE
- Chunk budgets use character-based token estimates, not tokenizer output; model windows verified June 2026.
Related Resources

Explore more resources that work well with this one.