@zakkster/lite-bake-stream 1.5.0 → 1.6.1

package/src/Views.js

@@ -1,6 +1,9 @@
 // @zakkster/lite-bake-stream / Views (internal)
 // Copyright (c) 2026 Zahary Shinikchiev. MIT.
 //
+// Error codes:
+//   W_BAD_SINK  - shared finalizeToSink guard: sink missing write/writeAt or async
+//
 // One shared helper so every container entry point (deserialize,
 // Reader.fromBuffer, PreserveReader.fromBuffer) resolves caller-supplied bytes
 // to an ArrayBuffer by exactly the SAME rule (BS-09). A Uint8Array that is a
@@ -23,3 +26,65 @@ export function toContainerBuffer(input, label) {
   throw new TypeError(label + ': expected ArrayBuffer or Uint8Array, got ' +
     (input === null ? 'null' : typeof input));
 }
+
+// ---- streaming sink support (M6) --------------------------------------------
+//
+// A sink is any object with a synchronous write(bytes) method; the streaming
+// (layout:'stream') path additionally needs writeAt(bytes, position) for the
+// single header backpatch. MemorySink is the in-RAM reference implementation
+// that finalize() drives internally so it can return the identical container
+// buffer the classic assembler produced.
+
+// Growable in-RAM sink. write() appends; writeAt() places bytes at an absolute
+// position (growing the logical length if needed); toArrayBuffer() returns an
+// EXACT-length ArrayBuffer copy of the bytes written.
+export class MemorySink {
+  constructor(hint) {
+    const cap = (typeof hint === 'number' && hint > 0) ? hint : 64 * 1024;
+    this._buf = new Uint8Array(cap);
+    this._len = 0;
+  }
+  _ensure(need) {
+    if (need <= this._buf.length) return;
+    let cap = this._buf.length;
+    while (cap < need) cap *= 2;
+    const next = new Uint8Array(cap);
+    next.set(this._buf.subarray(0, this._len));
+    this._buf = next;
+  }
+  write(bytes) {
+    this._ensure(this._len + bytes.length);
+    this._buf.set(bytes, this._len);
+    this._len += bytes.length;
+  }
+  writeAt(bytes, position) {
+    this._ensure(position + bytes.length);
+    this._buf.set(bytes, position);
+    if (position + bytes.length > this._len) this._len = position + bytes.length;
+  }
+  toArrayBuffer() {
+    return this._buf.buffer.slice(0, this._len);
+  }
+}
+
+// Cold prologue guard for finalizeToSink (raised as W_BAD_SINK by the writer):
+// the sink must be an object with write(); layout:'stream' also needs writeAt().
+export function validateSink(sink, needsWriteAt, raise) {
+  if (sink === null || typeof sink !== 'object') {
+    raise('W_BAD_SINK', 'sink must be an object with a write(bytes) method; got ' +
+      (sink === null ? 'null' : typeof sink));
+  }
+  if (typeof sink.write !== 'function') {
+    raise('W_BAD_SINK', 'sink is missing a write(bytes) method');
+  }
+  if (needsWriteAt && typeof sink.writeAt !== 'function') {
+    raise('W_BAD_SINK', "sink is missing a writeAt(bytes, position) method required for layout:'stream'");
+  }
+}
+
+// A sink write that returns a thenable is an async sink; the contract is
+// synchronous, so the writer treats it as a malformed sink (W_BAD_SINK).
+export function isThenable(v) {
+  return v !== null && (typeof v === 'object' || typeof v === 'function') &&
+    typeof v.then === 'function';
+}