@axpecter/lync 2.3.1 → 2.3.2

package/src/codec/composite/Map.luau

@@ -9,6 +9,13 @@ local Shared = require(script.Parent.Parent.composite.Shared)
 local Types = require(script.Parent.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.primitive.Varint)
 
+-- Constants --------------------------------------------------------------
+
+-- deltaMap wire flags. Distinct from Shared's struct/array flag spaces.
+local DM_UNCHANGED = 0
+local DM_FULL = 1
+local DM_DIFF = 2
+
 -- State ------------------------------------------------------------------
 
 --[[
@@ -21,8 +28,22 @@ local _keyDepth = 0
 
 -- Private ----------------------------------------------------------------
 
-local alloc = Base.alloc
+local ensure = Base.ensure
 local allocDeltaId = Shared.allocDeltaId
+local acquireScratch = Shared.acquireScratch
+local releaseScratch = Shared.releaseScratch
+local rangeEqual = Shared.rangeEqual
+local copyToBuf = Shared.copyToBuf
+local containsDelta = Shared.containsDelta
+local enforceMaxCount = Shared.enforceMaxCount
+local writeu8 = buffer.writeu8
+local readu8 = buffer.readu8
+local bufCopy = buffer.copy
+local bufLen = buffer.len
+local varintRead = Varint.read
+local varintWrite = Varint.write
+
+type DeltaMapEntry = { kBuf: buffer, kLen: number, vBuf: buffer, vLen: number }
 
 local function acquireKeys(): { any }
     _keyDepth += 1
@@ -44,6 +65,34 @@ local function tostringLess(a: any, b: any): boolean
     return tostring(a) < tostring(b)
 end
 
+local function sortKeys(keys: { any }, canSortDirect: boolean): ()
+    if canSortDirect then
+        table.sort(keys :: { any })
+    else
+        table.sort(keys, tostringLess)
+    end
+end
+
+--[[
+    Acquire a scratch keys array, populate it from `value`, nil any leftover
+    tail entries from a prior reuse, then sort. Returns the keys array and
+    the populated count. Caller MUST releaseKeys() after consuming the keys.
+]]
+local function collectAndSortKeys(value: { [any]: any }, canSortDirect: boolean): ({ any }, number)
+    local keys = acquireKeys()
+    local count = 0
+    for k in value do
+        count += 1
+        keys[count] = k
+    end
+    local prevTail = #keys
+    for i = count + 1, prevTail do
+        keys[i] = nil
+    end
+    sortKeys(keys, canSortDirect)
+    return keys, count
+end
+
 -- Public -----------------------------------------------------------------
 
 local Map = {}
@@ -56,6 +105,7 @@ function Map.map(
     local fixedKey = keyCodec._size
     local fixedValue = valueCodec._size
     local hasUnknown = keyCodec._hasUnknown or valueCodec._hasUnknown
+    local hasDelta = containsDelta(keyCodec) or containsDelta(valueCodec)
 
     --[[
         Numbers and strings sort by `<` directly; everything else (Instance,
@@ -82,61 +132,35 @@ function Map.map(
                 Log.error(`expected table, got {typeof(value)}`)
             end
 
-            local keys = acquireKeys()
-            local count = 0
-            for k in value do
-                count += 1
-                keys[count] = k
-            end
-
-            -- Drop tail entries from the prior reuse so table.sort sees only `count` items.
-            local prevTail = #keys
-            for i = count + 1, prevTail do
-                keys[i] = nil
-            end
+            local keys, count = collectAndSortKeys(value, canSortDirect)
 
-            Varint.write(ch, count)
+            varintWrite(ch, count)
             if count == 0 then
                 releaseKeys()
                 return
             end
 
-            if canSortDirect then
-                table.sort(keys :: { any })
-            else
-                table.sort(keys, tostringLess)
-            end
-
             -- Single alloc when both halves are fixed-size.
             if fixedKey and fixedValue then
-                local entrySize = fixedKey + fixedValue
-                local cursor = ch.cursor
-                if cursor + count * entrySize > ch.size then
-                    alloc(ch, count * entrySize)
-                end
+                ensure(ch, count * (fixedKey + fixedValue))
             end
 
             for i = 1, count do
                 local k = keys[i]
                 keyCodec.write(ch, k)
                 valueCodec.write(ch, value[k])
-                keys[i] = nil
             end
             releaseKeys()
         end,
 
         read = function(src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
-            local count, lenBytes = Varint.read(src, pos)
-            if maxCount and count > maxCount then
-                Log.error(`count {count} exceeds max {maxCount}`)
-            end
+            local count, lenBytes = varintRead(src, pos)
+            enforceMaxCount(count, maxCount)
 
             -- Fixed-size: reject corrupt counts before per-entry decode.
             if fixedKey and fixedValue and count > 0 then
-                local entrySize = fixedKey + fixedValue
-                local dataStart = pos + lenBytes
-                local payloadBytes = count * entrySize
-                if payloadBytes > buffer.len(src) - dataStart then
+                local payloadBytes = count * (fixedKey + fixedValue)
+                if payloadBytes > bufLen(src) - (pos + lenBytes) then
                     Log.error(`payload {payloadBytes}B exceeds remaining buffer`)
                 end
             end
@@ -162,19 +186,284 @@ function Map.map(
     if hasUnknown then
         codec._hasUnknown = true
     end
+    if hasDelta then
+        codec._hasDelta = true
+    end
     return table.freeze(codec)
 end
 
+--[[
+    Per-key deltaMap. Wire:
+      [0] UNCHANGED  (1 byte)
+      [1] FULL       <count varint> <(k,v) pairs ...>
+      [2] DIFF       <removeCount varint> <removed key bytes ...>
+                     <changeCount varint> <(k,v) pair bytes ...>
+
+    Cache: per-key encoded value bytes for byte-equality diffing plus per-key
+    encoded key bytes so removed-key emission doesn't re-encode the key codec
+    for keys that no longer live in the map.
+]]
 function Map.deltaMap(
     keyCodec: Types.InternalCodec<any>,
     valueCodec: Types.InternalCodec<any>,
     maxCount: number?
 ): Types.InternalCodec<any>
-    return Shared.makeUnchangedOrFullDelta(
-        Map.map(keyCodec, valueCodec, maxCount),
-        allocDeltaId(),
-        Baseline
-    )
+    -- Inner delta would chain-diff across pairs within a frame, not across frames.
+    if containsDelta(keyCodec) then
+        Log.error("deltaMap key codec cannot contain delta state")
+    end
+    if containsDelta(valueCodec) then
+        Log.error("deltaMap value codec cannot contain delta state")
+    end
+
+    local deltaId = allocDeltaId()
+    local typeCheck = keyCodec._typeCheck
+    local canSortDirect = typeCheck == "number" or typeCheck == "string"
+    local inner = Map.map(keyCodec, valueCodec, maxCount)
+
+    --[[
+        Encode each (key, value) pair into `scratch` and capture per-pair byte
+        ranges. Returns the sorted-keys list plus four parallel arrays of
+        offset/length so the diff path can compare and emit individual entries
+        without re-encoding.
+    ]]
+    local function encodePerKey(
+        scratch: Types.ChannelState,
+        value: { [any]: any }
+    ): ({ any }, { number }, { number }, { number }, { number })
+        local keys, count = collectAndSortKeys(value, canSortDirect)
+        local kOff = table.create(count)
+        local kLen = table.create(count)
+        local vOff = table.create(count)
+        local vLen = table.create(count)
+
+        for i = 1, count do
+            local k = keys[i]
+            local before = scratch.cursor
+            keyCodec.write(scratch, k)
+            local mid = scratch.cursor
+            kOff[i] = before
+            kLen[i] = mid - before
+            valueCodec.write(scratch, value[k])
+            vOff[i] = mid
+            vLen[i] = scratch.cursor - mid
+        end
+        return keys, kOff, kLen, vOff, vLen
+    end
+
+    return table.freeze({
+        _isDelta = true,
+        _isMap = true,
+        _keyCodec = keyCodec,
+        _valueCodec = valueCodec,
+        _maxCount = maxCount,
+
+        write = function(ch: Types.ChannelState, value: { [any]: any }): ()
+            if typeof(value) ~= "table" then
+                Log.error(`expected table, got {typeof(value)}`)
+            end
+
+            local cache = ch.deltas[deltaId] :: any
+            local scratch = acquireScratch()
+            local keys, kOff, kLen, vOff, vLen = encodePerKey(scratch, value)
+            local count = #keys
+            local scratchBuf = scratch.buff
+
+            -- First frame: emit FULL. Per-key scratch bytes ARE the inner map payload.
+            if not cache then
+                ensure(ch, 1)
+                writeu8(ch.buff, ch.cursor, DM_FULL)
+                ch.cursor += 1
+                varintWrite(ch, count)
+                local payloadLen = scratch.cursor
+                ensure(ch, payloadLen)
+                bufCopy(ch.buff, ch.cursor, scratchBuf, 0, payloadLen)
+                ch.cursor += payloadLen
+
+                local perKey: { [any]: DeltaMapEntry } = {}
+                for i = 1, count do
+                    local kbLen = kLen[i]
+                    local vbLen = vLen[i]
+                    perKey[keys[i]] = {
+                        kBuf = copyToBuf(nil, scratchBuf, kOff[i], kbLen),
+                        kLen = kbLen,
+                        vBuf = copyToBuf(nil, scratchBuf, vOff[i], vbLen),
+                        vLen = vbLen,
+                    }
+                end
+                ch.deltas[deltaId] = { perKey = perKey } :: any
+                releaseKeys()
+                releaseScratch()
+                return
+            end
+
+            local cachedPerKey = cache.perKey :: { [any]: DeltaMapEntry }
+
+            local seen: { [any]: boolean } = {}
+            local changed: { number } = {}
+            local changedCount = 0
+            for i = 1, count do
+                local k = keys[i]
+                seen[k] = true
+                local entry = cachedPerKey[k]
+                local newLen = vLen[i]
+                if
+                    not entry
+                    or newLen ~= entry.vLen
+                    or not rangeEqual(scratchBuf, vOff[i], entry.vBuf, 0, newLen)
+                then
+                    changedCount += 1
+                    changed[changedCount] = i
+                end
+            end
+
+            local removed: { any } = {}
+            local removedCount = 0
+            for k in cachedPerKey do
+                if not seen[k] then
+                    removedCount += 1
+                    removed[removedCount] = k
+                end
+            end
+
+            if removedCount == 0 and changedCount == 0 then
+                ensure(ch, 1)
+                writeu8(ch.buff, ch.cursor, DM_UNCHANGED)
+                ch.cursor += 1
+                releaseKeys()
+                releaseScratch()
+                return
+            end
+
+            -- Sort removed keys so the XOR baseline can collapse identical drops.
+            sortKeys(removed, canSortDirect)
+
+            ensure(ch, 1)
+            writeu8(ch.buff, ch.cursor, DM_DIFF)
+            ch.cursor += 1
+
+            varintWrite(ch, removedCount)
+            for i = 1, removedCount do
+                local entry = cachedPerKey[removed[i]]
+                local n = entry.kLen
+                ensure(ch, n)
+                bufCopy(ch.buff, ch.cursor, entry.kBuf, 0, n)
+                ch.cursor += n
+            end
+
+            varintWrite(ch, changedCount)
+            for i = 1, changedCount do
+                local idx = changed[i]
+                local kbLen = kLen[idx]
+                local vbLen = vLen[idx]
+                ensure(ch, kbLen + vbLen)
+                bufCopy(ch.buff, ch.cursor, scratchBuf, kOff[idx], kbLen)
+                bufCopy(ch.buff, ch.cursor + kbLen, scratchBuf, vOff[idx], vbLen)
+                ch.cursor += kbLen + vbLen
+            end
+
+            -- Update cache: drop removed, refresh changed, leave untouched in place.
+            for i = 1, removedCount do
+                cachedPerKey[removed[i]] = nil
+            end
+            for i = 1, changedCount do
+                local idx = changed[i]
+                local k = keys[idx]
+                local kbLen = kLen[idx]
+                local vbLen = vLen[idx]
+                local entry = cachedPerKey[k]
+                if entry then
+                    entry.kBuf = copyToBuf(entry.kBuf, scratchBuf, kOff[idx], kbLen)
+                    entry.kLen = kbLen
+                    entry.vBuf = copyToBuf(entry.vBuf, scratchBuf, vOff[idx], vbLen)
+                    entry.vLen = vbLen
+                else
+                    cachedPerKey[k] = {
+                        kBuf = copyToBuf(nil, scratchBuf, kOff[idx], kbLen),
+                        kLen = kbLen,
+                        vBuf = copyToBuf(nil, scratchBuf, vOff[idx], vbLen),
+                        vLen = vbLen,
+                    }
+                end
+            end
+
+            releaseKeys()
+            releaseScratch()
+        end,
+
+        read = function(src: buffer, pos: number, refs: { Instance }?): ({ [any]: any }, number)
+            if pos >= bufLen(src) then
+                Log.error("truncated deltaMap header")
+            end
+            local flag = readu8(src, pos)
+
+            if flag == DM_UNCHANGED then
+                local cached = Baseline.getCache(deltaId)
+                if cached == nil then
+                    Log.error("UNCHANGED flag before any FULL frame; baseline missing")
+                end
+                return cached, 1
+            end
+
+            if flag == DM_FULL then
+                local value, consumed = inner.read(src, pos + 1, refs)
+                Baseline.setCache(deltaId, value)
+                return value, 1 + consumed
+            end
+
+            if flag == DM_DIFF then
+                local cached = Baseline.getCache(deltaId)
+                if cached == nil then
+                    Log.error("deltaMap DIFF before any FULL frame; baseline missing")
+                end
+                local result: { [any]: any } = table.clone(cached)
+                local total = 1
+
+                local removeCount, rcLen = varintRead(src, pos + total)
+                if rcLen == 0 then
+                    Log.error("truncated deltaMap remove count")
+                end
+                -- Both counts bounded by maxCount; otherwise a malicious DIFF
+                -- could spin the loop arbitrarily long before erroring on
+                -- buffer overrun.
+                enforceMaxCount(removeCount, maxCount, "removeCount")
+                total += rcLen
+                for _ = 1, removeCount do
+                    local k, kc = keyCodec.read(src, pos + total, refs)
+                    if kc == 0 then
+                        Log.error("truncated deltaMap removed key")
+                    end
+                    total += kc
+                    result[k] = nil
+                end
+
+                local changeCount, ccLen = varintRead(src, pos + total)
+                if ccLen == 0 then
+                    Log.error("truncated deltaMap change count")
+                end
+                enforceMaxCount(changeCount, maxCount, "changeCount")
+                total += ccLen
+                for _ = 1, changeCount do
+                    local k, kc = keyCodec.read(src, pos + total, refs)
+                    if kc == 0 then
+                        Log.error("truncated deltaMap changed key")
+                    end
+                    total += kc
+                    local v, vc = valueCodec.read(src, pos + total, refs)
+                    if vc == 0 then
+                        Log.error("truncated deltaMap changed value")
+                    end
+                    total += vc
+                    result[k] = v
+                end
+
+                Baseline.setCache(deltaId, result)
+                return result, total
+            end
+
+            Log.error(`invalid deltaMap flag {flag}`)
+        end,
+    }) :: Types.InternalCodec<any>
 end
 
 return table.freeze(Map)

package/src/codec/composite/Optional.luau

@@ -4,6 +4,7 @@
 
 local Channel = require(script.Parent.Parent.Parent.internal.Channel)
 local Log = require(script.Parent.Parent.Parent.util.Log)
+local Shared = require(script.Parent.Parent.composite.Shared)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Private ----------------------------------------------------------------
@@ -44,6 +45,9 @@ function Optional.optional(inner: Types.InternalCodec<any>): Types.InternalCodec
     if inner._hasUnknown then
         codec._hasUnknown = true
     end
+    if Shared.containsDelta(inner) then
+        codec._hasDelta = true
+    end
     return table.freeze(codec)
 end
 

package/src/codec/composite/Shared.luau

@@ -11,14 +11,14 @@ local Types = require(script.Parent.Parent.Parent.Types)
 -- Constants --------------------------------------------------------------
 
 --[[
-    Delta flag space, shared across deltaStruct/deltaArray/deltaMap:
-      0    UNCHANGED  (decoder reuses cache)
-      1    FULL       (full payload follows)
-    Struct's per-segment scheme uses [1..segCount] as a single-dirty-segment
-    index, then segCount + DELTA_FULL_OFFSET / + DELTA_MULTI_OFFSET.
+    Delta flag base shared by deltaStruct's per-segment scheme:
+      0    UNCHANGED
+      1..segCount             single dirty segment k
+      segCount + FULL_OFFSET  FULL payload
+      segCount + MULTI_OFFSET MULTI: bitmap + dirty segs in order
+    deltaArray and deltaMap manage their own flag spaces.
 ]]
 local DELTA_UNCHANGED = 0
-local DELTA_FULL = 1
 local DELTA_FULL_OFFSET = 1
 local DELTA_MULTI_OFFSET = 2
 
@@ -37,9 +37,29 @@ local lshift = bit32.lshift
 local readu8 = buffer.readu8
 local writeu8 = buffer.writeu8
 local bufCopy = buffer.copy
+local bufLen = buffer.len
 local rangeEqual = Buf.rangeEqual
 local snapshot = Buf.snapshot
 
+--[[
+    Reuse `existing` when it's already large enough, else snapshot via
+    Buf.snapshot. Avoids per-write buffer allocations on delta caches that
+    hover at a stable size.
+]]
+local function copyToBuf(existing: buffer?, src: buffer, srcOff: number, len: number): buffer
+    if existing and bufLen(existing) >= len then
+        bufCopy(existing, 0, src, srcOff, len)
+        return existing
+    end
+    return snapshot(src, len, srcOff)
+end
+
+-- Update a `{raw, len}` cache shape from scratch bytes; reuses raw via copyToBuf.
+local function refreshCache(cache: any, src: buffer, len: number): ()
+    cache.raw = copyToBuf(cache.raw, src, 0, len)
+    cache.len = len
+end
+
 -- Public -----------------------------------------------------------------
 
 local Shared = {}
@@ -49,6 +69,20 @@ Shared.DELTA_FULL_OFFSET = DELTA_FULL_OFFSET
 Shared.DELTA_MULTI_OFFSET = DELTA_MULTI_OFFSET
 Shared.rangeEqual = rangeEqual
 Shared.snapshot = snapshot
+Shared.refreshCache = refreshCache
+Shared.copyToBuf = copyToBuf
+
+-- True when `c` itself is a delta codec OR contains one in its tree.
+function Shared.containsDelta(c: Types.InternalCodec<any>): boolean
+    return c._isDelta == true or c._hasDelta == true
+end
+
+-- Common bounds check for variable-length container codecs.
+function Shared.enforceMaxCount(len: number, maxCount: number?, label: string?): ()
+    if maxCount and len > maxCount then
+        Log.error(`{label or "count"} {len} exceeds max {maxCount}`)
+    end
+end
 
 function Shared.allocDeltaId(): number
     _nextDeltaId += 1
@@ -82,6 +116,26 @@ function Shared.releaseScratch(): ()
     _scratchDepth -= 1
 end
 
+--[[
+    Reset module-private state. Called by Sandbox in tests so that a thrown
+    codec.write (which skips releaseScratch and leaves depth inflated) can't
+    leak into the next test's scratch acquisition. Also resets the deltaId
+    counter so test ordering doesn't bleed.
+]]
+function Shared.reset(): ()
+    _scratchDepth = 0
+    _nextDeltaId = 0
+    for i = 1, #_scratchStack do
+        local ch = _scratchStack[i]
+        ch.cursor = 0
+        ch.refCount = 0
+        if ch.refCount > 0 then
+            table.clear(ch.refs)
+        end
+        table.clear(ch.deltas)
+    end
+end
+
 --[[
     Split a struct schema into (dataKeys, dataCodecs, boolKeys), each sorted
     alphabetically for deterministic wire layout.
@@ -234,79 +288,4 @@ function Shared.unpackBoolArray(
     return byteCount
 end
 
---[[
-    Build a byte-equality delta codec around any inner codec. Wire:
-      [DELTA_UNCHANGED]                       1 byte
-      [DELTA_FULL]  <inner-encoded payload>   1 + N bytes
-    Used by deltaArray and deltaMap. The FULL path encodes once into scratch
-    then bufCopies into the channel — avoids a double encode.
-]]
-function Shared.makeUnchangedOrFullDelta(
-    inner: Types.InternalCodec<any>,
-    deltaId: number,
-    Baseline: {
-        getCache: (number) -> any,
-        setCache: (number, any) -> (),
-    }
-): Types.InternalCodec<any>
-    return table.freeze({
-        _isDelta = true,
-
-        write = function(ch: Types.ChannelState, value: any): ()
-            local scratch = Shared.acquireScratch()
-            inner.write(scratch, value)
-            local scratchLen = scratch.cursor
-
-            local cache = ch.deltas[deltaId]
-            if
-                cache
-                and scratchLen == cache.len
-                and rangeEqual(scratch.buff, 0, cache.raw, 0, scratchLen)
-            then
-                local cursor = ch.cursor
-                if cursor + 1 > ch.size then
-                    alloc(ch, 1)
-                end
-                writeu8(ch.buff, cursor, DELTA_UNCHANGED)
-                ch.cursor = cursor + 1
-                Shared.releaseScratch()
-                return
-            end
-
-            local cursor = ch.cursor
-            if cursor + 1 + scratchLen > ch.size then
-                alloc(ch, 1 + scratchLen)
-            end
-            local b = ch.buff
-            writeu8(b, cursor, DELTA_FULL)
-            if scratchLen > 0 then
-                bufCopy(b, cursor + 1, scratch.buff, 0, scratchLen)
-            end
-            ch.cursor = cursor + 1 + scratchLen
-
-            local snap = snapshot(scratch.buff, scratchLen)
-            if cache then
-                cache.raw = snap
-                cache.len = scratchLen
-            else
-                ch.deltas[deltaId] = { raw = snap, len = scratchLen }
-            end
-            Shared.releaseScratch()
-        end,
-
-        read = function(src: buffer, pos: number, refs: { Instance }?): (any, number)
-            if readu8(src, pos) == DELTA_UNCHANGED then
-                local cached = Baseline.getCache(deltaId)
-                if not cached then
-                    Log.error("UNCHANGED flag before any FULL frame; baseline missing")
-                end
-                return cached, 1
-            end
-            local value, consumed = inner.read(src, pos + 1, refs)
-            Baseline.setCache(deltaId, value)
-            return value, 1 + consumed
-        end,
-    })
-end
-
 return table.freeze(Shared)

package/src/codec/composite/Struct.luau

@@ -55,6 +55,7 @@ local packBools = Shared.packBools
 local unpackBools = Shared.unpackBools
 local rangeEqual = Shared.rangeEqual
 local snapshot = Shared.snapshot
+local refreshCache = Shared.refreshCache
 local acquireScratch = Shared.acquireScratch
 local releaseScratch = Shared.releaseScratch
 local allocDeltaId = Shared.allocDeltaId
@@ -89,14 +90,18 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
     local boolCount = #boolKeys
     local boolBytes = Shared.boolBytes(boolCount)
 
-    -- Single pass: detect all-direct fast-write path + propagate _hasUnknown.
+    -- Single pass: detect all-direct fast-write path + propagate _hasUnknown / _hasDelta.
     local allDirect, fixedSize = true, 0
     local hasUnknown = false
+    local hasDelta = false
     for i = 1, dataCount do
         local c = dataCodecs[i]
         if c._hasUnknown then
             hasUnknown = true
         end
+        if Shared.containsDelta(c) then
+            hasDelta = true
+        end
         if allDirect then
             if c._size and c._directWrite and c._directRead then
                 fixedSize += c._size
@@ -194,6 +199,9 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
         if hasUnknown then
             codec._hasUnknown = true
         end
+        if hasDelta then
+            codec._hasDelta = true
+        end
         return table.freeze(codec)
     end
 
@@ -226,6 +234,9 @@ function Struct.struct(schema: { [string]: Types.InternalCodec<any> }): Types.In
     if hasUnknown then
         codec._hasUnknown = true
     end
+    if hasDelta then
+        codec._hasDelta = true
+    end
     return table.freeze(codec)
 end
 
@@ -421,8 +432,7 @@ function Struct.deltaStruct(
                 end
             end
 
-            cache.raw = snapshot(scratch.buff, scratchLen)
-            cache.len = scratchLen;
+            refreshCache(cache, scratch.buff, scratchLen);
             (cache :: any).segOff = segOff;
             (cache :: any).segLen = segLen
             releaseScratch()