Fix stale precision and encodeLossless references in docs

Update terminology from precision to resolution and encodeLossless to
encode(value, true) across README.md, CLAUDE.md, copilot-instructions.md,
and index.html to match the current API after PR #92.

Author: 0xferit

.github/copilot-instructions.md

@@ -12,7 +12,7 @@ The core implementation is `UintQuantizationLib` in `src/UintQuantizationLib.sol
 - `Quant` layout is fixed: bits 0-7 = `shift`, bits 8-15 = `targetBits`.
 - Keep custom errors file-level with bare names (`BadConfig`, `Overflow`, `NotAligned`).
 - Keep fuzz constraints consistent with existing tests (`bound()` instead of `vm.assume`).
-- For precision-sensitive flows, prefer `encodeLossless`; for floor truncation use `encode`.
+- For resolution-sensitive flows, prefer `encode(value, true)`; for floor truncation use `encode`.
 
 ## Validation commands
 

CLAUDE.md

@@ -21,7 +21,7 @@ forge test
 forge test --match-path test/UintQuantizationLib.t.sol
 
 # Run a single test function
-forge test --match-test test_encodeLossless_notAligned_reverts
+forge test --match-test test_encodePrecise_notAligned_reverts
 
 # Run with verbose output
 forge test -vv

README.md

@@ -49,7 +49,7 @@ The `Quant` value type is a `uint16` with the following bit layout:
 | `q.shift()` | Returns the shift component (bits discarded during encoding). |
 | `q.targetBits()` | Returns the targetBits component (bit-width of the encoded value). |
 | `q.encode(value)` | Floor-encodes `value`. Reverts with `Overflow` when `value > max(q)`. |
-| `q.encodeLossless(value)` | Strict mode: also reverts with `NotAligned` when `value` is not step-aligned. |
+| `q.encode(value, true)` | Strict mode: also reverts with `NotAligned` when `value` is not step-aligned. |
 | `q.decode(encoded)` | Left-shifts `encoded` by shift, restoring discarded bits as zeros (lower bound). |
 | `q.decodeMax(encoded)` | Like `decode` but fills discarded bits with ones (upper bound within the step). |
 | `q.fits(value)` | Returns `true` when `value <= max(q)`. |
@@ -86,7 +86,7 @@ contract StakingVault {
 
     /// Strict mode: reverts if msg.value is not step-aligned.
     function stakeExact() external payable {
-        stakes[msg.sender] = uint96(SCHEME.encodeLossless(msg.value));
+        stakes[msg.sender] = uint96(SCHEME.encode(msg.value, true));
     }
 
     /// Restores the lower-bound value (what was actually stored).
@@ -114,7 +114,7 @@ contract StakingVault {
         return SCHEME.remainder(amount);
     }
 
-    /// True when `amount` is step-aligned (no precision loss).
+    /// True when `amount` is step-aligned (no resolution loss).
     function isDepositLossless(uint256 amount) external pure returns (bool) {
         return SCHEME.isLossless(amount);
     }
@@ -131,18 +131,18 @@ contract StakingVault {
 }
 ```
 
-> `encode()` and `encodeLossless()` return `uint256` due to Solidity type constraints. The encoded
+> `encode(value)` and `encode(value, true)` return `uint256` due to Solidity type constraints. The encoded
 > result is guaranteed to fit in `2^targetBits - 1`, so store it using the matching `uintN` for
 > your scheme (for example, `uint16` for `targetBits=16`, `uint24` for `targetBits=24`). Using a
 > smaller type will silently truncate.
 
 ## Which encode function should I use?
 
-> - `encode` — Floor encoding with overflow check. Reverts when the value exceeds `max(q)`.
-> - `encodeLossless` — Strict mode: reverts on overflow or when any precision would be lost.
+> - `encode(value)` — Floor encoding with overflow check. Reverts when the value exceeds `max(q)`.
+> - `encode(value, true)` — Strict mode: reverts on overflow or when any resolution would be lost.
 
 Use `encode` when the caller controls or bounds the input and floor truncation is acceptable.
-Use `encodeLossless` when exactness is a protocol requirement (e.g., the transaction should revert
+Use `encode(value, true)` when exactness is a protocol requirement (e.g., the transaction should revert
 rather than silently truncate the value).
 
 ## Showcase and gas savings
@@ -162,7 +162,7 @@ state layout.
 
 The staking showcase intentionally exercises the full API surface:
 - `stake()` uses `encode`.
-- `stakeExact()` uses `encodeLossless`.
+- `stakeExact()` uses `encode(value, true)`.
 - `unstake()` uses `decode`.
 - `maxDeposit()`, `stakeRemainder()`, and `isStakeLossless()` expose
   `max`, `remainder`, and `isLossless` for frontend UX.

index.html

@@ -173,7 +173,7 @@ <h2 class="section-title sr">API</h2>
       <div class="api-list sr" style="transition-delay:0.1s">
         <div class="api-item"><code class="api-fn">create(shift, targetBits)</code><span class="api-desc">Create a quantization scheme</span></div>
         <div class="api-item"><code class="api-fn">encode(value)</code><span class="api-desc">Floor-encode a value (reverts on overflow)</span></div>
-        <div class="api-item"><code class="api-fn">encodeLossless(value)</code><span class="api-desc">Strict encode (reverts if value is not step-aligned)</span></div>
+        <div class="api-item"><code class="api-fn">encode(value, true)</code><span class="api-desc">Strict encode (reverts if value is not step-aligned)</span></div>
         <div class="api-item"><code class="api-fn">decode(encoded)</code><span class="api-desc">Restore lower-bound value</span></div>
         <div class="api-item"><code class="api-fn">decodeMax(encoded)</code><span class="api-desc">Restore upper-bound value</span></div>
         <div class="api-item"><code class="api-fn">fits(value)</code><span class="api-desc">Check if value is representable</span></div>