@amritk/nish-x86_64-linux 0.21.0 → 0.22.1

package/std/json.ts

@@ -1220,8 +1220,9 @@ export class JsonWriter {
    * `bytes[off .. off + len)`, copied as it is and counted as one value: a
    * fragment the caller encoded already, such as a cached object. Nothing in
    * it is checked, so a fragment that is not one whole JSON value makes a
-   * text that is not JSON either. The bytes are copied front to back, so
-   * `bytes` is not the writer's own buffer at a window the copy overtakes.
+   * text that is not JSON either. The bytes are copied in one move
+   * (`copyBytes`), as if all were read before any was written, so a window
+   * of the writer's own buffer comes out as it was.
    * In an indented text the fragment goes in where a value would, after its
    * line break and indent, but its own bytes are not re-indented: an object
    * fragment stays on one line, where `JSON.stringify` would spread it out.
@@ -1243,11 +1244,7 @@ export class JsonWriter {
       this.failed = JSON_WRITE_FULL
       return
     }
-    for (let k: i32 = 0; k < len && off + k < toI32(bytes.length) && at + k < toI32(buf.length); k += 1) {
-      if (off + k >= 0 && at + k >= 0) {
-        buf[at + k] = bytes[off + k]
-      }
-    }
+    copyBytes(buf, at, bytes, off, len)
     this.end = at + len
     jsonWriterValueDone(this)
   }

package/std/net/http1-server.ts

@@ -113,6 +113,7 @@
  * implementation.
  */
 import { Secret } from "nish:secret"
+import { copyBytes } from "nish/bytes"
 import { netClose, netRead, netWrite, tcpAccept } from "nish:net"
 import {
   HTTP1_BODY,
@@ -120,6 +121,8 @@ import {
   HTTP1_CLOSED,
   HTTP1_END,
   HTTP1_ERROR,
+  HTTP1_FIRST_HEAD,
+  HTTP1_FIRST_INPUT,
   HTTP1_HEAD,
   HTTP1_NO_BODY,
   HTTP1_REFUSED,
@@ -240,6 +243,11 @@ const http1ServerCheckWindow = (what: string, buf: u8[], off: i32, len: i32): vo
 
 /** Copies `src[off .. off + n)` to `out` at `at`, which the caller has made sure holds it, and answers where it ends. */
 const http1ServerCopy = (out: u8[], at: i32, src: u8[], off: i32, n: i32): i32 => {
+  if (n > 0 && at >= 0 && off >= 0 && at <= toI32(out.length) - n && off <= toI32(src.length) - n) {
+    // Both windows fit, as they do for every caller: one move, not a byte loop.
+    copyBytes(out, at, src, off, n)
+    return at + n
+  }
   for (let k: i32 = 0; k < n && at + k < toI32(out.length) && off + k < toI32(src.length); k++) {
     if (at + k >= 0 && off + k >= 0) {
       out[at + k] = src[off + k]
@@ -352,6 +360,15 @@ export class Http1Config {
    * of its head each `idleTimeout` would hold its slot for good (slowloris).
    */
   headTimeout: i32 = 30000
+  /**
+   * Lend a slot's input and head buffers back to the server between
+   * exchanges: once a response is sent and no byte of the next request has
+   * come, the slot gives both to pools the server's slots share, and takes
+   * them again with the next byte. The memory they hold then follows the
+   * connections mid-request rather than every keep-alive connection open,
+   * for two pool operations a request. Off by default.
+   */
+  idleInput: boolean = false
 }
 
 /** The reason phrase a status is sent with; RFC 9112 §4 lets a client ignore it. */
@@ -470,8 +487,12 @@ export class Http1Connection {
   date: HttpDate
   /** The request parser: its head (`methodIs`, `targetIs`, `header`, spans) is the last `H1_REQUEST`'s. */
   parser: Http1Parser
-  /** The frame decoder, once the slot has switched to WebSocket. */
-  ws: WsDecoder
+  /**
+   * The frame decoder: made when the slot first switches to WebSocket, so a
+   * slot that only ever speaks HTTP never holds its buffers, then kept for
+   * the slot's later peers.
+   */
+  ws: WsDecoder | null
   /**
    * Bytes to send are `output[outputStart .. outputEnd)`. Empty until the
    * connection first needs room to write: then its own buffer, made once, or
@@ -482,9 +503,12 @@ export class Http1Connection {
   noOutput: u8[]
   /** Where `output` is borrowed from, for a connection of a pool; null for one that keeps its own. */
   pool: Http1OutputPool | null
+  /** Where the parser's input and head buffers go while the slot rests, with `Http1Config.idleInput`; null otherwise. */
+  inputs: Http1OutputPool | null
+  heads: Http1OutputPool | null
   /** `H1_BODY`'s and `H1_WS_MESSAGE`'s bytes. */
   data: u8[]
-  /** A ping's payload, kept until its pong fits. */
+  /** A ping's payload, kept until its pong fits: empty until the first ping. */
   pong: u8[]
   /** No fields, for the responses the connection writes itself: made once. */
   noFields: u8[][]
@@ -561,12 +585,14 @@ export class Http1Connection {
     this.parser = new Http1Parser(config.maxTarget, config.maxHeaderBytes, config.maxHeaders, config.maxBody)
     this.parser.keepText = false
     this.parser.maxChunk = config.chunkSize
-    this.ws = new WsDecoder(true, config.maxMessage)
+    this.ws = null
     this.noOutput = []
     this.output = this.noOutput
     this.pool = null
+    this.inputs = null
+    this.heads = null
     this.data = this.noOutput
-    this.pong = new Array<u8>(WS_MAX_CONTROL)
+    this.pong = this.noOutput
     this.noFields = []
     // A line must fit whole before the parser can read it, so the buffer
     // holds the longest request line or field line however small a chunk is.
@@ -584,7 +610,10 @@ export class Http1Connection {
   /** Puts the connection back as the constructor left it, for the next peer. It allocates nothing. */
   restart(): void {
     this.parser.restart()
-    this.ws.reset()
+    const ws: WsDecoder | null = this.ws
+    if (ws !== null) {
+      ws.reset()
+    }
     this.outputStart = 0
     this.outputEnd = 0
     this.data = this.noOutput
@@ -608,6 +637,49 @@ export class Http1Connection {
     this.headTimed = false
     this.headSince = 0
     this.release()
+    this.park()
+  }
+
+  /**
+   * Gives the parser's input and head buffers to `inputs` and `heads` while
+   * the connection rests between exchanges: speaking HTTP, no request open,
+   * nothing fed and unread. Does nothing without the pools or otherwise.
+   */
+  park(): void {
+    const inputs: Http1OutputPool | null = this.inputs
+    const heads: Http1OutputPool | null = this.heads
+    const p: Http1Parser = this.parser
+    if (inputs === null || heads === null || this.state !== H1_S_HTTP || this.requestOpen || !p.resting()) {
+      return
+    }
+    if (toI32(p.buf.length) > 0) {
+      inputs.give(p.buf)
+      p.buf = this.noOutput
+      p.body = this.noOutput
+      p.start = 0
+      p.end = 0
+      p.scan = 0
+      p.lineStart = 0
+      p.lineEnd = 0
+    }
+    if (toI32(p.head.length) > 0) {
+      heads.give(p.head)
+      p.head = this.noOutput
+    }
+  }
+
+  /** Takes back the buffers `park` gave away, before bytes are fed. */
+  unpark(): void {
+    const inputs: Http1OutputPool | null = this.inputs
+    const heads: Http1OutputPool | null = this.heads
+    const p: Http1Parser = this.parser
+    if (inputs !== null && toI32(p.buf.length) === 0) {
+      p.buf = inputs.take()
+      p.body = p.buf
+    }
+    if (heads !== null && toI32(p.head.length) === 0) {
+      p.head = heads.take()
+    }
   }
 
   // ---- Bytes in and out ---------------------------------------------------------
@@ -622,7 +694,9 @@ export class Http1Connection {
     if (this.writeHeld || this.inputEnded || this.state === H1_S_CLOSING || this.state === H1_S_FAILED) {
       return 0
     }
-    const held: i32 = this.state === H1_S_WEBSOCKET ? this.ws.end - this.ws.start : this.parser.buffered()
+    const ws: WsDecoder | null = this.ws
+    const held: i32 =
+      this.state === H1_S_WEBSOCKET && ws !== null ? ws.end - ws.start : this.parser.buffered()
     const room: i32 = this.inputLimit() - held
     return room > 0 ? room : 0
   }
@@ -640,8 +714,9 @@ export class Http1Connection {
       return 0
     }
     if (this.state === H1_S_WEBSOCKET) {
-      this.ws.feed(buf, off, n)
+      this.decoder().feed(buf, off, n)
     } else {
+      this.unpark()
       this.parser.feed(buf, off, n)
     }
     return n
@@ -727,12 +802,8 @@ export class Http1Connection {
     const output: u8[] = this.output
     const live: i32 = this.outputEnd - this.outputStart
     if (this.outputStart > 0) {
-      for (
-        let k: i32 = 0;
-        k < live && k < toI32(output.length) && this.outputStart + k < toI32(output.length);
-        k++
-      ) {
-        output[k] = output[this.outputStart + k]
+      if (live > 0 && this.outputStart <= toI32(output.length) - live) {
+        copyBytes(output, 0, output, this.outputStart, live)
       }
       this.outputStart = 0
       this.outputEnd = live
@@ -784,8 +855,9 @@ export class Http1Connection {
         this.response = H1_R_NONE
         if (this.upgraded) {
           const p: Http1Parser = this.parser
-          this.ws.reset()
-          this.ws.feed(p.buf, p.start, p.buffered())
+          const ws: WsDecoder = this.decoder()
+          ws.reset()
+          ws.feed(p.buf, p.start, p.buffered())
           this.state = H1_S_WEBSOCKET
           return this.nextFrame()
         }
@@ -867,35 +939,50 @@ export class Http1Connection {
     return H1_ERROR
   }
 
+  /** The frame decoder, made on the slot's first switch to WebSocket. */
+  decoder(): WsDecoder {
+    const ws: WsDecoder | null = this.ws
+    if (ws !== null) {
+      return ws
+    }
+    const made: WsDecoder = new WsDecoder(true, this.config.maxMessage)
+    this.ws = made
+    return made
+  }
+
   /** `next` once the slot has switched to WebSocket. */
   nextFrame(): i32 {
     while (true) {
       if (this.pongPending && !this.sendPong()) {
         return H1_NEED_MORE
       }
-      const event: i32 = this.ws.next()
+      const ws: WsDecoder = this.decoder()
+      const event: i32 = ws.next()
       if (event === WS_MESSAGE) {
-        this.opcode = this.ws.opcode
-        this.data = this.ws.data
+        this.opcode = ws.opcode
+        this.data = ws.data
         this.dataStart = 0
-        this.dataLength = this.ws.dataLen
+        this.dataLength = ws.dataLen
         return H1_WS_MESSAGE
       }
       if (event === WS_PING) {
-        const n: i32 = this.ws.dataLen
-        for (let k: i32 = 0; k < n && k < toI32(this.pong.length) && k < toI32(this.ws.data.length); k++) {
-          this.pong[k] = this.ws.data[k]
+        const n: i32 = ws.dataLen
+        if (this.pong.length === 0) {
+          this.pong = new Array<u8>(WS_MAX_CONTROL)
+        }
+        for (let k: i32 = 0; k < n && k < toI32(this.pong.length) && k < toI32(ws.data.length); k++) {
+          this.pong[k] = ws.data[k]
         }
         this.pongLength = n
         this.pongPending = true
       } else if (event === WS_CLOSE) {
-        this.status = this.ws.closeCode
-        this.sendClose(this.ws.closeCode)
+        this.status = ws.closeCode
+        this.sendClose(ws.closeCode)
         this.state = H1_S_CLOSING
         return H1_WS_CLOSE
       } else if (event === WS_ERROR) {
-        this.status = this.ws.closeCode
-        this.sendClose(this.ws.closeCode)
+        this.status = ws.closeCode
+        this.sendClose(ws.closeCode)
         this.state = H1_S_FAILED
         return H1_ERROR
       } else if (event === WS_NEED_MORE) {
@@ -935,7 +1022,7 @@ export class Http1Connection {
     const payload: u8[] | null = websocketClosePayload(code, "")
     // A code that may not be sent (1005, for a close that had none) is
     // answered with an empty close.
-    const body: u8[] = payload === null ? this.pong : payload
+    const body: u8[] = payload === null ? this.noOutput : payload
     const n: i32 = payload === null ? H1_ZERO : toI32(body.length)
     const end: i32 = websocketWriteFrame(
       this.output,
@@ -1245,6 +1332,30 @@ export class Http1Connection {
   expired(now: i64): boolean {
     return this.idle(now) || this.headLate(now)
   }
+
+  /**
+   * The soonest `expired` can turn true, however the connection moves from
+   * here: `lastActive` only grows, and a head clock not yet started starts
+   * no earlier than it.
+   */
+  expiresNoSooner(): i64 {
+    const idle: i64 = toI64(this.config.idleTimeout) * toI64(1000000)
+    const head: i64 = toI64(this.config.headTimeout) * toI64(1000000)
+    const soonest: i64 = this.lastActive + (head < idle ? head : idle)
+    if (this.headTimed && this.headSince + head < soonest) {
+      return this.headSince + head
+    }
+    return soonest
+  }
+}
+
+/**
+ * The soonest any slot accepted after now can expire: no sooner than the
+ * shorter of `idleTimeout` and `headTimeout` from now.
+ */
+const http1ExpireFloor = (config: Http1Config): i64 => {
+  const shorter: i32 = config.headTimeout < config.idleTimeout ? config.headTimeout : config.idleTimeout
+  return monotonicNanos() + toI64(shorter) * toI64(1000000)
 }
 
 // ---- Carriers -------------------------------------------------------------------
@@ -1273,6 +1384,9 @@ export class Http1Server {
   armed: i32[]
   /** The output buffers the slots borrow while they write. */
   outputs: Http1OutputPool
+  /** The input and head buffers resting slots lend, with `Http1Config.idleInput`. */
+  inputs: Http1OutputPool
+  heads: Http1OutputPool
   /**
    * The slots closed since they were used, a stack whose top `accept` takes
    * before it builds a slot past the high-water mark: finding one costs the
@@ -1288,6 +1402,14 @@ export class Http1Server {
   slots: i32 = 1
   /** The listening socket, which the program made with `tcpListen` and still owns. */
   listener: i32 = -1
+  /**
+   * No slot can expire before this (`monotonicNanos`), so `expire` called
+   * sooner walks none: it walks every slot only about once per the shorter
+   * timeout, however many there are.
+   */
+  expireAfter: i64 = 0
+  /** How many calls of `expire` walked every slot, for a program measuring its cost. */
+  expireScans: i32 = 0
 
   /**
    * A pool of `size` slots, at least one, serving `config` on `listener`.
@@ -1305,6 +1427,8 @@ export class Http1Server {
     this.free = []
     this.slots = size < 1 ? 1 : size
     this.outputs = new Http1OutputPool(config.outputSize)
+    this.inputs = new Http1OutputPool(HTTP1_FIRST_INPUT)
+    this.heads = new Http1OutputPool(HTTP1_FIRST_HEAD)
     this.date = new HttpDate()
     this.scratch = new Array<u8>(config.chunkSize)
     this.peer = new Array<u8>(H1_ADDRESS_SIZE)
@@ -1315,6 +1439,10 @@ export class Http1Server {
     const conn: Http1Connection = new Http1Connection(this.config)
     conn.pool = this.outputs
     conn.date = this.date
+    if (this.config.idleInput) {
+      conn.inputs = this.inputs
+      conn.heads = this.heads
+    }
     this.connections.push(conn)
     return conn
   }
@@ -1473,6 +1601,7 @@ export class Http1Server {
     if (conn.isDone()) {
       return H1_DONE
     }
+    conn.park()
     let wants: i32 = 0
     if (conn.inputRoom() > 0) {
       wants = wants | H1_WANT_READ
@@ -1538,13 +1667,24 @@ export class Http1Server {
    * head for longer than `headTimeout`, at `now` (`monotonicNanos`); answers how many.
    */
   expire(now: i64): i32 {
+    if (now < this.expireAfter) {
+      return 0
+    }
+    this.expireScans = this.expireScans + 1
+    let soonest: i64 = http1ExpireFloor(this.config)
     let n: i32 = 0
     for (let k: i32 = 0; k < toI32(this.fds.length) && k < toI32(this.connections.length); k++) {
-      if (this.fds[k] >= 0 && this.connections[k].expired(now)) {
-        this.close(k)
-        n = n + 1
+      if (this.fds[k] >= 0) {
+        const conn = this.connections[k]
+        if (conn.expired(now)) {
+          this.close(k)
+          n = n + 1
+        } else if (conn.expiresNoSooner() < soonest) {
+          soonest = conn.expiresNoSooner()
+        }
       }
     }
+    this.expireAfter = soonest
     return n
   }
 }
@@ -1580,6 +1720,13 @@ export class Http1TlsServer {
   scratch: u8[]
   /** The output buffers the slots borrow while they write. */
   outputs: Http1OutputPool
+  /** The input and head buffers resting slots lend, with `Http1Config.idleInput`. */
+  inputs: Http1OutputPool
+  heads: Http1OutputPool
+  /** No slot can expire before this (`monotonicNanos`): `Http1Server.expireAfter`. */
+  expireAfter: i64 = 0
+  /** How many calls of `expire` walked every slot. */
+  expireScans: i32 = 0
 
   /**
    * A pool of `size` slots, at least one, serving `config` over TLS under
@@ -1593,6 +1740,8 @@ export class Http1TlsServer {
     this.tls = new TlsTcpServer(tlsConfig, listener, size)
     this.connections = []
     this.outputs = new Http1OutputPool(config.outputSize)
+    this.inputs = new Http1OutputPool(HTTP1_FIRST_INPUT)
+    this.heads = new Http1OutputPool(HTTP1_FIRST_HEAD)
     this.date = new HttpDate()
     this.scratch = new Array<u8>(config.chunkSize)
   }
@@ -1613,6 +1762,10 @@ export class Http1TlsServer {
     const conn: Http1Connection = new Http1Connection(this.config)
     conn.pool = this.outputs
     conn.date = this.date
+    if (this.config.idleInput) {
+      conn.inputs = this.inputs
+      conn.heads = this.heads
+    }
     return conn
   }
 
@@ -1776,6 +1929,7 @@ export class Http1TlsServer {
     if (conn.isDone()) {
       return this.tls.shutdown(slot)
     }
+    conn.park()
     const wants: i32 = this.tls.interest(slot)
     return conn.wantsWrite() && (wants & TLS_RECORD_DONE) === 0 ? wants | TLS_RECORD_WANT_WRITE : wants
   }
@@ -1816,13 +1970,24 @@ export class Http1TlsServer {
    * head for longer than `headTimeout`, at `now` (`monotonicNanos`); answers how many.
    */
   expire(now: i64): i32 {
+    if (now < this.expireAfter) {
+      return 0
+    }
+    this.expireScans = this.expireScans + 1
+    let soonest: i64 = http1ExpireFloor(this.config)
     let n: i32 = 0
     for (let k: i32 = 0; k < this.tls.size() && k < toI32(this.connections.length); k++) {
-      if (this.tls.holds(k) && this.connections[k].expired(now)) {
-        this.tls.close(k)
-        n = n + 1
+      if (this.tls.holds(k)) {
+        const conn = this.connections[k]
+        if (conn.expired(now)) {
+          this.tls.close(k)
+          n = n + 1
+        } else if (conn.expiresNoSooner() < soonest) {
+          soonest = conn.expiresNoSooner()
+        }
       }
     }
+    this.expireAfter = soonest
     return n
   }
 }

package/std/net/http1.ts

@@ -80,6 +80,7 @@
  *
  * Written from RFC 9112 and RFC 9110, not ported from another implementation.
  */
+import { copyBytes } from "nish/bytes"
 
 /** `next()`: the input so far holds no further event; feed more. */
 export const HTTP1_NEED_MORE: i32 = 0
@@ -234,11 +235,15 @@ export class Http1Parser {
     this.maxHeaderBytes = http1Clamp(maxHeaderBytes)
     this.maxHeaders = http1Clamp(maxHeaders)
     this.maxBody = http1Clamp(maxBody)
-    this.buf = new Array<u8>(1024)
+    // The input and the head are made by the first byte fed and the first
+    // head kept, at HTTP1_FIRST_INPUT and HTTP1_FIRST_HEAD bytes: a parser
+    // that is built and never fed (a pool's spare slot) costs neither, and a
+    // caller that lends them out between requests puts empty ones here.
+    this.buf = []
     this.body = this.buf
     this.names = []
     this.values = []
-    this.head = new Array<u8>(256)
+    this.head = []
     this.spans = new Array<i32>(64)
     this.tally = new Http1ListTally()
     this.restart()
@@ -261,19 +266,9 @@ export class Http1Parser {
     http1Reserve(this, len)
     const buf: u8[] = this.buf
     const at: i32 = this.end
-    // A whole array is one `set`, a memmove; a window is copied byte by byte,
-    // because `set` takes no window of its source.
-    if (off === 0 && len === size) {
-      buf.set(data, at)
-      this.end = at + len
-      return
-    }
-    for (let k: i32 = 0; k < len; k += 1) {
-      const to: i32 = at + k
-      if (to >= 0 && to < toI32(buf.length)) {
-        buf[to] = data[off + k]
-      }
-    }
+    // One move: http1Reserve made room for `len` bytes at `at`, and the
+    // window was checked above.
+    copyBytes(buf, at, data, off, len)
     this.end = at + len
   }
 
@@ -359,6 +354,16 @@ export class Http1Parser {
     return http1HeadIs(this.head, spans[4 * found + 2], spans[4 * found + 3], protocol, true)
   }
 
+  /**
+   * Whether the parser waits for a request line with nothing fed and unread,
+   * so its input and head buffers hold nothing it needs: a caller may lend
+   * them out and leave empty arrays in `buf`, `body` and `head`, which the
+   * next feed and head make or the caller puts back first.
+   */
+  resting(): boolean {
+    return this.state === HTTP1_S_REQUEST_LINE && this.end === this.start
+  }
+
   /** How many bytes were fed and not consumed yet: what a caller bounds its reads by. */
   buffered(): i32 {
     return this.end - this.start
@@ -410,6 +415,11 @@ export class Http1Parser {
   }
 }
 
+/** The input buffer a parser makes on its first feed, the smallest it grows from. */
+export const HTTP1_FIRST_INPUT: i32 = 1024
+/** The head buffer a parser makes for its first head. */
+export const HTTP1_FIRST_HEAD: i32 = 256
+
 /** Makes room for `len` more bytes at `p.end`, moving the live bytes down first. */
 const http1Reserve = (p: Http1Parser, len: i32): void => {
   const old: u8[] = p.buf
@@ -418,7 +428,7 @@ const http1Reserve = (p: Http1Parser, len: i32): void => {
     return
   }
   const live: i32 = p.end - p.start
-  let size: i32 = capacity
+  let size: i32 = capacity < HTTP1_FIRST_INPUT ? HTTP1_FIRST_INPUT : capacity
   while (size - live < len) {
     if (size > 1073741823) {
       panic("Http1Parser: more than 2^31 - 1 bytes buffered")
@@ -429,8 +439,9 @@ const http1Reserve = (p: Http1Parser, len: i32): void => {
   // the live bytes move to the front, and every index into them moves too.
   const buf: u8[] = size === capacity ? old : new Array<u8>(size)
   const from: i32 = p.start
-  for (let k: i32 = 0; k < live && k < toI32(buf.length); k += 1) {
-    buf[k] = old[from + k]
+  if (live > 0) {
+    // One move, overlapping when the buffer is the same one.
+    copyBytes(buf, 0, old, from, live)
   }
   p.buf = buf
   p.lineStart -= from
@@ -601,6 +612,9 @@ const http1HeadAppend = (p: Http1Parser, from: i32, to: i32): i32 => {
   const at: i32 = p.headLength
   let size: i32 = toI32(p.head.length)
   if (n > size - at) {
+    if (size < HTTP1_FIRST_HEAD) {
+      size = HTTP1_FIRST_HEAD
+    }
     while (size - at < n) {
       if (size > 1073741823) {
         panic("Http1Parser: a head of more than 2^31 - 1 bytes")
@@ -616,9 +630,14 @@ const http1HeadAppend = (p: Http1Parser, from: i32, to: i32): i32 => {
   }
   const head: u8[] = p.head
   const buf: u8[] = p.buf
-  for (let k: i32 = 0; k < n && at + k < toI32(head.length) && from + k < toI32(buf.length); k += 1) {
-    if (from + k >= 0) {
-      head[at + k] = buf[from + k]
+  if (n > 0 && from >= 0 && from <= toI32(buf.length) - n && at <= toI32(head.length) - n) {
+    // The line lies in `buf` and the head was grown to hold it: one move.
+    copyBytes(head, at, buf, from, n)
+  } else {
+    for (let k: i32 = 0; k < n && at + k < toI32(head.length) && from + k < toI32(buf.length); k += 1) {
+      if (from + k >= 0) {
+        head[at + k] = buf[from + k]
+      }
     }
   }
   p.headLength = at + n