functionalscript · sergey-shandar · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026
diff --git a/changelog/unreleased/1566.md b/changelog/unreleased/1566.md
@@ -0,0 +1,3 @@
+- **BREAKING CHANGES:** `types/byte_set`: `toRangeMap` takes only the set and
+  returns `RangeMap<boolean>` instead of taking a state name and returning
+  `RangeMap<SortedSet<string>>`. Callers label the ranges themselves
diff --git a/fjs/fsm/module.f.mjs b/fjs/fsm/module.f.mjs
@@ -50,9 +50,22 @@ const mergeOp = { union: sortedSetUnion(cmp), equal: equal(strictEqual), def: []
 /** @type {(s: string) => (set: SortedSet<string>) => boolean} */
 const hasState = s => set => !isEmpty(intersect(cmp)([s])(set))
 
+/**
+ * Labels a byte set's ranges with the rule they lead to: a range inside the set
+ * transitions to `ruleOut`, one outside transitions nowhere.
+ *
+ * `byte_set.toRangeMap` answers only whether each range is in the set; which
+ * state that means is a DFA question, so it is answered here.
+ *
+ * @type {(ruleOut: string) => (entry: Entry<boolean>) => Entry<SortedSet<string>>}
+ */
+const labelRange = ruleOut => ([inSet, max]) => [inSet ? [ruleOut] : [], max]
+
 /** @type {(set: SortedSet<string>) => Fold<_Rule, RangeMap<SortedSet<string>>>} */
 const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
-    if (hasState(ruleIn)(set)) { return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut)) }
+    if (hasState(ruleIn)(set)) {
+        return merge(mergeOp)(rm)(map(labelRange(ruleOut))(toRangeMap(bs)))
+    }
     return rm
 }
 

diff --git a/fjs/types/byte_set/module.f.mjs b/fjs/types/byte_set/module.f.mjs
@@ -5,7 +5,6 @@
  * @module
  *
  * @import { RangeMap } from '../range_map/types.ts'
- * @import { SortedSet } from '../sorted_set/types.ts'
  * @import { ByteSet } from './types.ts'
  */
 
@@ -57,12 +56,21 @@ export const unset = n => s => difference(s)(one(n))
 
 const counter = reverse(countdown(256))
 
-/** @type {(n: ByteSet) => (s: string) => (i: number) => RangeMap<SortedSet<string>>} */
-const toRangeMapOp = n => s => i => {
+/** @type {(n: ByteSet) => (i: number) => RangeMap<boolean>} */
+const toRangeMapOp = n => i => {
     const current = has(i + 1)(n)
     const prev = has(i)(n)
-    return current === prev ? null : [[prev ? [s] : [], i]]
+    return current === prev ? null : [[prev, i]]
 }
 
-/** @type {(n: ByteSet) => (s: string) => RangeMap<SortedSet<string>>} */
-export const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter))
+/**
+ * Re-expresses the set as a range map: one entry per membership boundary,
+ * carrying whether the range up to that byte is in the set.
+ *
+ * The payload is the set's own answer — `boolean` — and nothing more. A caller
+ * that needs ranges labelled with something else maps over the result; that
+ * labelling belongs to the caller, not to a byte set.
+ *
+ * @type {(n: ByteSet) => RangeMap<boolean>}
+ */
+export const toRangeMap = n => flat(map(toRangeMapOp(n))(counter))
diff --git a/fjs/types/byte_set/proof.f.mjs b/fjs/types/byte_set/proof.f.mjs
@@ -65,22 +65,22 @@ export const proof = {
     },
     toRangeMap: [
         () => {
-            const result = stringify(toArray(toRangeMap(empty)('a')))
+            const result = stringify(toArray(toRangeMap(empty)))
             assertEq(result, '[]')
         },
         () => {
             const s = set(0)(empty)
-            const result = stringify(toArray(toRangeMap(s)('a')))
-            assertEq(result, '[[["a"],0]]')
+            const result = stringify(toArray(toRangeMap(s)))
+            assertEq(result, '[[true,0]]')
         },
         () => {
             const s = setRange([1, 2])(empty)
-            const result = stringify(toArray(toRangeMap(s)('a')))
-            assertEq(result, '[[[],0],[["a"],2]]')
+            const result = stringify(toArray(toRangeMap(s)))
+            assertEq(result, '[[false,0],[true,2]]')
         },
         () => {
-            const result = stringify(toArray(toRangeMap(universe)('a')))
-            assertEq(result, '[[["a"],255]]')
+            const result = stringify(toArray(toRangeMap(universe)))
+            assertEq(result, '[[true,255]]')
         },
     ]
 }
diff --git a/fjs/types/byte_set/todo/torangemap-payload.md b/fjs/types/byte_set/todo/torangemap-payload.md