Fix #698, #699, #700: replace, count loop cap, exit program

Docs/03-language-basics/control-flow.md

@@ -523,6 +523,63 @@ end check
 
 This is automatic and helps performance!
 
+## Stopping the Program
+
+`exit program` stops the whole program where it stands, with a successful
+status:
+
+```wfl
+store name as "world"
+
+check if name is equal to "":
+    display "Please give me a name."
+    exit program
+end check
+
+display "Hello, " with name
+```
+
+It works anywhere — at top level, inside a loop, inside an action, or inside a
+`try` block — and nothing after it runs:
+
+```wfl
+define action called require with parameters value and message:
+    check if value is equal to "":
+        display message
+        exit program
+    end check
+end action
+
+store user_name as ""
+call require with user_name and "usage: greet <name>"
+display "Hello, " with user_name
+```
+
+Because stopping is not a failure, a `when error:` handler never catches
+`exit program`. A `finally:` block still runs, so cleanup is not skipped. In a
+websocket handler it stops the server too, rather than being reported as a
+handler error.
+
+**What counts as "the program".** Code you bring in with `load module from` or
+`include from` becomes part of the program that included it, so stopping inside
+it stops everything. A program you launch with `execute file` is a *separate*
+program: `exit program` there ends that run and hands control back to the
+caller, which carries on.
+
+**`exit program` vs `exit loop`:**
+
+| Spelling | What it leaves |
+|---|---|
+| `break` | The innermost loop |
+| `exit loop` (or bare `exit`) | Every enclosing loop |
+| `exit program` | The program |
+
+`exit loop` is about loops only: outside one it has nothing to leave and does
+nothing, exactly like a `break` written outside a loop. Write `exit program`
+when you mean "stop here".
+
+To stop with a *failure* status instead, raise an error rather than exiting.
+
 ## Common Mistakes
 
 ### Forgetting `end check`

Docs/03-language-basics/loops-and-iteration.md

@@ -57,6 +57,32 @@ count from <start> to <end> by <step>:
 end count
 ```
 
+The step is a *distance*, so it is always a positive number: a downward loop
+(`count from 10 down to 1 by 2`) subtracts it. A step of `0` or a negative step
+could never reach the end value, so it is reported as an error instead of
+looping forever. A loop whose range is already empty never runs its body, so
+its step is never used and never checked — `count from 5 to 1` does nothing,
+whatever step you give it.
+
+A step also has to be big enough to actually move the counter. Past about 9
+quadrillion, numbers lose the precision to add 1 to them, so
+`count from 100000000000000000 to 100000000000000100 by 1` would sit on the
+same value forever. WFL reports that instead of running it.
+
+### How Many Times a Count Loop May Run
+
+As many times as you ask it to. A count loop has no built-in trip limit —
+`count from 1 to 20000` runs 20,000 times, exactly like the equivalent
+`repeat while` or `for each`. A loop that never finishes is stopped by the
+execution timeout (`timeout_seconds` in `.wflcfg`, 60 seconds by default),
+which is the same protection every other loop form gets.
+
+One exception is worth knowing if you write servers: inside a `main loop` the
+execution timeout is suspended, because a server must not time out on its own
+uptime. Every loop form is unbounded there, count loops included, so a loop
+inside a request handler is only as bounded as the values you give it. Keep
+handler loop ranges under your own control rather than a caller's.
+
 ### Count Examples
 
 **Count to 100 by tens:**
@@ -268,7 +294,7 @@ end repeat
 
 ### Break (Exit Loop)
 
-Exit a loop early (if supported):
+Exit a loop early:
 
 ```wfl
 count from 1 to 100:
@@ -281,9 +307,35 @@ end count
 display "Loop exited at 5"
 ```
 
+`exit loop` (or a bare `exit`) does the same thing, except that it leaves
+*every* enclosing loop rather than only the innermost one:
+
+```wfl
+count from 1 to 3 as row:
+    count from 1 to 3 as col:
+        display row with "," with col
+        check if col is equal to 2:
+            exit loop  // leaves both loops
+        end check
+    end count
+end count
+
+display "Done"
+```
+
+**Output:**
+```
+1,1
+1,2
+Done
+```
+
+To stop the whole program rather than a loop, use `exit program` — see
+[Stopping the Program](control-flow.md#stopping-the-program).
+
 ### Continue (Skip)
 
-Skip to the next iteration (if supported):
+Skip to the next iteration:
 
 ```wfl
 count from 1 to 10:

Docs/04-advanced-features/pattern-matching.md

@@ -288,6 +288,51 @@ otherwise:
 end check
 ```
 
+## Replacing Matches
+
+`replace ... with ... in ...` returns a new text with every match replaced:
+
+```wfl
+create pattern separator:
+    "-" or "_"
+end pattern
+
+store raw as "first-name_last"
+store cleaned as replace separator with " " in raw
+display cleaned
+```
+
+**Output:**
+```
+first name last
+```
+
+**Syntax:**
+```wfl
+replace <pattern or text> with <replacement> in <text>
+```
+
+The thing being replaced may be a pattern *or* a plain text, which is matched
+verbatim — the same statement whether you have grown into patterns yet or not:
+
+```wfl
+store greeting as "hello world world"
+display replace "world" with "there" in greeting
+```
+
+**Output:**
+```
+hello there there
+```
+
+Matches are replaced left to right and never overlap; the original text is
+unchanged, so store the result if you need it. A pattern that matches nothing
+returns the text as-is.
+
+The replacement text is inserted literally. Referring to a capture group from
+the replacement is not supported yet — build the result with `find all` and
+text concatenation when you need that.
+
 ## Real-World Patterns
 
 ### Email Validation

Docs/05-standard-library/pattern-module.md

@@ -152,6 +152,53 @@ end for
 
 ---
 
+### pattern_replace
+
+**Purpose:** Replace every match of a pattern with a replacement text.
+
+**Signature:**
+```wfl
+replace <pattern> with <replacement> in <text>
+```
+
+**Parameters:**
+- `pattern` (Pattern or Text): What to look for. A compiled pattern, or a
+  literal text matched verbatim (see [replace in the Text module](text-module.md#replace))
+- `replacement` (Text): What each match becomes
+- `text` (Text): Text to search
+
+**Returns:** Text - a new text; the original is unchanged
+
+**Example:**
+```wfl
+create pattern spaces:
+    one or more whitespace
+end pattern
+
+store messy as "too   many    spaces"
+store tidy as replace spaces with " " in messy
+display tidy
+```
+
+**Output:**
+```
+too many spaces
+```
+
+Every match is replaced, left to right, and the scan resumes after each match
+— matches never overlap. A pattern that matches nothing returns the text
+unchanged.
+
+**Use Cases:**
+- Normalize whitespace or separators
+- Redact matched text
+- Rewrite formats in place
+
+**Note:** The replacement is inserted literally; there is no syntax yet for
+referring to a capture group from the replacement text.
+
+---
+
 ## Pattern in Conditions
 
 The most common usage is in conditionals:

Docs/05-standard-library/text-module.md

@@ -395,6 +395,57 @@ store directories as split of filepath by "/"
 
 ---
 
+### replace
+
+**Purpose:** Replace every occurrence of one text with another.
+
+**Signature:**
+```wfl
+replace <needle> with <replacement> in <text>
+```
+
+**Parameters:**
+- `needle` (Text or Pattern): What to look for. A plain text is matched
+  verbatim — characters that mean something in a pattern are just characters
+  here. A [pattern](pattern-module.md#pattern_replace) may be used instead
+- `replacement` (Text): What each occurrence becomes
+- `text` (Text): The text to search
+
+**Returns:** Text - a new text; the original is unchanged
+
+**Example:**
+```wfl
+store path as "home/user/documents"
+store windows_path as replace "/" with "\\" in path
+display windows_path
+```
+
+**Output:**
+```
+home\user\documents
+```
+
+**More examples:**
+```wfl
+store greeting as "hello world world"
+display replace "world" with "there" in greeting
+// Output: hello there there
+
+store spaced as "a.b.c"
+display replace "." with "-" in spaced
+// Output: a-b-c
+```
+
+Occurrences are replaced left to right and never overlap. A needle that does
+not occur returns the text unchanged.
+
+**Use Cases:**
+- Swap separators
+- Redact or mask text
+- Normalize input before comparison
+
+---
+
 ### format_number
 
 **Purpose:** Format a number as text with a fixed number of decimal places.

Docs/reference/keyword-reference.md

@@ -29,7 +29,7 @@ Quick lookup for all WFL reserved keywords.
 | `downward` | Count loop direction | ✗ |
 | `each` | For each loop | ✗ |
 | `end` | Close block | ✗ |
-| `exit` | Exit program/loop | ✗ |
+| `exit` | Exit loops (`exit loop`) or the program (`exit program`) | ✗ |
 | `for` | For loop | ✗ |
 | `forever` | Infinite loop | ✗ |
 | `from` | Count loop start | ✗ |
@@ -152,7 +152,7 @@ Quick lookup for all WFL reserved keywords.
 | `one` | Quantifier (one or more) | ✗ |
 | `optional` | Optional quantifier | ✗ |
 | `pattern` | Pattern definition | ✓ |
-| `replace` | Pattern replacement | ✗ |
+| `replace` | Pattern or text replacement | ✗ |
 | `script` | Unicode script | ✗ |
 | `split` | Split by pattern | ✗ |
 | `start` | Start anchor | ✗ |

Docs/reference/reserved-keywords.md

@@ -607,7 +607,7 @@ Complete reference table of all 181 keywords.
 | `exactly` | Other | Pattern | ❌ | `exactly 5 times` |
 | `execute` | Other | Process | ❌ | `execute command` |
 | `exists` | Other | File I/O | ❌ | `file exists` |
-| `exit` | Other | Control Flow | ❌ | `exit program` |
+| `exit` | Other | Control Flow | ❌ | `exit loop` / `exit program` |
 | `extension` | Contextual | File I/O | ✅ | `file extension` |
 | `extensions` | Contextual | File I/O | ✅ | `file extensions` |
 | `extends` | Structural | OOP | ❌ | `container extends` |
@@ -681,7 +681,7 @@ Complete reference table of all 181 keywords.
 | `register` | Other | Web/Network | ❌ | `register handler` |
 | `remove` | Other | Operations | ❌ | `remove item` |
 | `repeat` | Structural | Control Flow | ❌ | `repeat 10 times` |
-| `replace` | Other | Pattern | ❌ | `replace pattern` |
+| `replace` | Other | Pattern | ❌ | `replace <pattern or text> with <text> in <text>` |
 | `request` | Other | Web/Network | ❌ | `HTTP request` |
 | `requires` | Structural | OOP | ❌ | `requires action` |
 | `respond` | Other | Web/Network | ❌ | `respond to request` |