Merge branch 'per-side-border-69' of github.com:bombshell-dev/clayterm into per-side-border-69

Author: rauhryan

ops.ts

@@ -190,9 +190,11 @@ export function pack(
           );
           o += 4;
 
-          // Resolved per-side attributes (CSS-like fallback expansion done
-          // here, not in C): fg/bg word pairs in top, right, bottom, left
-          // order. The C renderer consumes these as explicit values.
+          // Must match render_border() in src/clayterm.c.
+          // Resolve CSS-like side fallbacks here, then write eight required
+          // attribute words: fg/bg pairs in top, right, bottom, left order.
+          // C treats the presence and order of these words as a wire-format
+          // invariant and only consumes the explicit values.
           for (let side of [b.top, b.right, b.bottom, b.left]) {
             view.setUint32(o, sideFg(side, b.color), true);
             o += 4;

src/clayterm.c

@@ -303,17 +303,26 @@ static void render_text(struct Clayterm *ct, int x0, int y0,
 static void render_border(struct Clayterm *ct, int x0, int y0, int x1, int y1,
                           Clay_RenderCommand *cmd) {
   Clay_BorderRenderData *b = &cmd->renderData.border;
-  /* userData points at eight words in the command buffer carrying resolved
-   * per-side attributes as fg/bg pairs in top, right, bottom, left order.
-   * Fallback resolution (shared color/bg vs side overrides) happens on the
-   * TypeScript side; this renderer consumes explicit values only. The
-   * command buffer outlives the render pass within reduce(). */
+  /* Must match border packing in ops.ts.
+   * userData points at eight required words in the command buffer: resolved
+   * fg/bg pairs in top, right, bottom, left order. Fallback resolution
+   * (shared color/bg vs side overrides) happens on the TypeScript side; this
+   * renderer consumes explicit values only. The command buffer outlives the
+   * render pass within reduce(). Missing userData is a wire-format violation.
+   */
   const uint32_t *s = (const uint32_t *)cmd->userData;
-  uint32_t deffg = color(b->color);
-  uint32_t top_fg = s ? s[0] : deffg, top_bg = s ? s[1] : ATTR_DEFAULT;
-  uint32_t right_fg = s ? s[2] : deffg, right_bg = s ? s[3] : ATTR_DEFAULT;
-  uint32_t bot_fg = s ? s[4] : deffg, bot_bg = s ? s[5] : ATTR_DEFAULT;
-  uint32_t left_fg = s ? s[6] : deffg, left_bg = s ? s[7] : ATTR_DEFAULT;
+  if (s == NULL) {
+    __builtin_trap();
+  }
+
+  uint32_t top_fg = s[0];
+  uint32_t top_bg = s[1];
+  uint32_t right_fg = s[2];
+  uint32_t right_bg = s[3];
+  uint32_t bot_fg = s[4];
+  uint32_t bot_bg = s[5];
+  uint32_t left_fg = s[6];
+  uint32_t left_bg = s[7];
   int top = b->width.top > 0;
   int bot = b->width.bottom > 0;
   int left = b->width.left > 0;

term-native.ts

@@ -16,6 +16,15 @@ const BoundingBoxStruct = struct<BoundingBox>({
 
 const BOUNDING_BOX = offsets(BoundingBoxStruct);
 
+const WASM_PAGE_BYTES = 65536;
+const TEXT_TRANSFER_BUFFER_BYTES = 1024 * 1024;
+const CLAY_DEFAULT_MAX_ELEMENT_COUNT = 8192;
+
+// Conservative fixed wire-format budget per element. This covers the largest
+// non-text open/close element encoding we currently support; text, element id,
+// and snapshot payload bytes live in TEXT_TRANSFER_BUFFER_BYTES.
+const MAX_FIXED_ELEMENT_WIRE_BYTES = 116;
+
 export interface Native {
   memory: WebAssembly.Memory;
   statePtr: number;
@@ -92,10 +101,15 @@ export async function createTermNative(
   let heap = ct.__heap_base.value as number;
   let size = ct.clayterm_size(w, h);
 
-  // grow memory to fit heap + state + ops buffer (1MB headroom for ops)
-  let needed = heap + size + 1024 * 1024;
-  let pages = Math.ceil(needed / 65536);
-  let current = memory.buffer.byteLength / 65536;
+  // Grow memory once to fit heap + renderer state + fixed transfer buffer.
+  // The transfer budget is intentionally fixed: text/id/snapshot payload bytes
+  // get 1MB, and fixed op overhead gets one max-sized element per Clay element.
+  // Do not grow this dynamically per render; improve the wire format instead.
+  let transferBytes = TEXT_TRANSFER_BUFFER_BYTES +
+    CLAY_DEFAULT_MAX_ELEMENT_COUNT * MAX_FIXED_ELEMENT_WIRE_BYTES;
+  let needed = heap + size + transferBytes;
+  let pages = Math.ceil(needed / WASM_PAGE_BYTES);
+  let current = memory.buffer.byteLength / WASM_PAGE_BYTES;
   if (pages > current) {
     memory.grow(pages - current);
   }