@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/src/shared/render-records-v1.mjs

@@ -0,0 +1,168 @@
+// Render-record stream v1 encoder (docs/render-records-v1.md). Browser-safe,
+// dependency-free; the C++ render core transliterates this exactly — the two
+// serializations are byte-compared by GATE R.
+
+export const RENDER_RECORDS_MAGIC = 0x52524331; // 'RRC1'
+
+export const RECORD_CLEAR = 1;
+export const RECORD_DRAW = 2;
+export const RECORD_UPLOAD_TEXTURE = 3;
+export const RECORD_DYNAMIC_BUFFER = 4;
+
+class ByteWriter {
+  constructor() {
+    this.chunks = [];
+    this.length = 0;
+  }
+  push(bytes) {
+    this.chunks.push(bytes);
+    this.length += bytes.byteLength;
+  }
+  u8(value) {
+    this.push(Uint8Array.of(value & 0xff));
+  }
+  u32(value) {
+    const view = new DataView(new ArrayBuffer(4));
+    view.setUint32(0, value >>> 0, true);
+    this.push(new Uint8Array(view.buffer));
+  }
+  i32(value) {
+    const view = new DataView(new ArrayBuffer(4));
+    view.setInt32(0, value | 0, true);
+    this.push(new Uint8Array(view.buffer));
+  }
+  f32(value) {
+    const view = new DataView(new ArrayBuffer(4));
+    view.setFloat32(0, Math.fround(value), true);
+    this.push(new Uint8Array(view.buffer));
+  }
+  string(value) {
+    const bytes = new TextEncoder().encode(String(value));
+    this.u32(bytes.byteLength);
+    this.push(bytes);
+  }
+  bytes(bytes) {
+    this.u32(bytes.byteLength);
+    this.push(new Uint8Array(bytes.buffer ?? bytes, bytes.byteOffset ?? 0, bytes.byteLength));
+  }
+  concat() {
+    const out = new Uint8Array(this.length);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      out.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return out;
+  }
+}
+
+function writeBufferRef(writer, ref) {
+  if (ref.staticSha256) {
+    writer.u8(1);
+    writer.string(ref.staticSha256);
+  } else if (ref.dynamicSlot) {
+    writer.u8(2);
+    writer.string(ref.dynamicSlot);
+  } else {
+    throw new Error(`buffer ref needs staticSha256 or dynamicSlot: ${JSON.stringify(ref)}`);
+  }
+}
+
+function writeCommand(writer, command) {
+  writer.u8(command.kind);
+  if (command.kind === RECORD_CLEAR) {
+    writer.i32(command.fbId);
+    writer.u32(command.mask);
+    writer.u8(command.color ? 1 : 0);
+    if (command.color) for (const c of command.color) writer.f32(c);
+    writer.u8(command.depth === null || command.depth === undefined ? 0 : 1);
+    if (command.depth !== null && command.depth !== undefined) writer.f32(command.depth);
+    return;
+  }
+  if (command.kind === RECORD_DRAW) {
+    writer.string(command.programKey);
+    writer.i32(command.fbId);
+    writer.u32(command.mode);
+    writer.u32(command.count);
+    writer.u32(command.instanceCount ?? 1);
+    writer.u8(command.indexed ? 1 : 0);
+    if (command.indexed) {
+      writer.u32(command.indexType);
+      writer.u32(command.indexOffset ?? 0);
+      writeBufferRef(writer, command.elementBuffer);
+    }
+    writer.u8(command.blendOn ? 1 : 0);
+    writer.u8(command.frontFaceCW ? 1 : 0);
+    // v2 additions (magic stays 'RRC1'; all streams carry these)
+    writer.u8(command.cullEnabled ? 1 : 0);
+    writer.u8(command.depthTest ? 1 : 0);
+    writer.u8(command.depthMask ? 1 : 0);
+    if (typeof command.depthFunc !== 'number') throw new Error(`DRAW record missing depthFunc: ${command.programKey}`);
+    writer.u32(command.depthFunc);
+    for (const v of command.viewport) writer.u32(v);
+    writer.u32(command.uniforms.length);
+    for (const uniform of command.uniforms) {
+      writer.string(uniform.name);
+      writer.u32(uniform.glType);
+      writer.u32(uniform.values.length);
+      for (const value of uniform.values) writer.f32(value);
+    }
+    writer.u32(command.samplers.length);
+    for (const sampler of command.samplers) {
+      writer.string(sampler.name);
+      writer.u32(sampler.unit);
+      writer.string(sampler.textureKey);
+    }
+    writer.u32(command.attribs.length);
+    for (const attrib of command.attribs) {
+      writer.u32(attrib.location);
+      writer.u32(attrib.size);
+      writer.u32(attrib.glType);
+      writer.u8(attrib.normalized ? 1 : 0);
+      writer.u32(attrib.stride);
+      writer.u32(attrib.offset);
+      writer.u32(attrib.divisor);
+      writer.u8(attrib.integer ? 1 : 0);
+      writeBufferRef(writer, attrib.buffer);
+    }
+    return;
+  }
+  if (command.kind === RECORD_UPLOAD_TEXTURE) {
+    writer.string(command.textureKey);
+    writer.u32(command.width);
+    writer.u32(command.height);
+    writer.u32(command.format);
+    writer.u32(command.type);
+    writer.u32(command.internalformat);
+    writer.u8(command.flipY ? 1 : 0);
+    writer.u8(command.premultiply ? 1 : 0);
+    writer.u32(command.unpackAlignment);
+    writer.u32(command.minFilter);
+    writer.u32(command.magFilter);
+    writer.u32(command.wrapS);
+    writer.u32(command.wrapT);
+    writer.u8(command.generateMipmap ? 1 : 0); // v2
+    writer.bytes(command.bytes);
+    return;
+  }
+  if (command.kind === RECORD_DYNAMIC_BUFFER) {
+    writer.string(command.slotKey);
+    writer.bytes(command.bytes);
+    return;
+  }
+  throw new Error(`unknown record kind ${command.kind}`);
+}
+
+export function encodeRenderRecordStream(stream) {
+  const writer = new ByteWriter();
+  writer.u32(RENDER_RECORDS_MAGIC);
+  writer.u32(stream.viewport.width);
+  writer.u32(stream.viewport.height);
+  writer.u32(stream.frames.length);
+  for (const frame of stream.frames) {
+    writer.u32(frame.frameIndex);
+    writer.u32(frame.commands.length);
+    for (const command of frame.commands) writeCommand(writer, command);
+  }
+  return writer.concat();
+}

package/src/shared/sha256.mjs

@@ -0,0 +1,73 @@
+const SHA256_K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+function rotr(x, n) {
+  return ((x >>> n) | (x << (32 - n))) >>> 0;
+}
+
+export function sha256Hex(bytes) {
+  const len = bytes.length;
+  const paddedLen = (((len + 8) >> 6) + 1) << 6;
+  const padded = new Uint8Array(paddedLen);
+  padded.set(bytes);
+  padded[len] = 0x80;
+  const dv = new DataView(padded.buffer);
+  dv.setUint32(paddedLen - 8, Math.floor(len / 0x20000000), false);
+  dv.setUint32(paddedLen - 4, (len << 3) >>> 0, false);
+
+  const h = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ]);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLen; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = dv.getUint32(offset + i * 4, false);
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+    }
+    let a = h[0];
+    let b = h[1];
+    let cc = h[2];
+    let d = h[3];
+    let e = h[4];
+    let f = h[5];
+    let g = h[6];
+    let hh = h[7];
+    for (let i = 0; i < 64; i += 1) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (hh + S1 + ch + SHA256_K[i] + w[i]) >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & cc) ^ (b & cc);
+      const t2 = (S0 + maj) >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = (d + t1) >>> 0;
+      d = cc;
+      cc = b;
+      b = a;
+      a = (t1 + t2) >>> 0;
+    }
+    h[0] = (h[0] + a) >>> 0;
+    h[1] = (h[1] + b) >>> 0;
+    h[2] = (h[2] + cc) >>> 0;
+    h[3] = (h[3] + d) >>> 0;
+    h[4] = (h[4] + e) >>> 0;
+    h[5] = (h[5] + f) >>> 0;
+    h[6] = (h[6] + g) >>> 0;
+    h[7] = (h[7] + hh) >>> 0;
+  }
+  let hex = '';
+  for (let i = 0; i < 8; i += 1) hex += h[i].toString(16).padStart(8, '0');
+  return hex;
+}