@smoothbricks/lmao 0.1.0

package/src/lib/codegen/__tests__/__snapshots__/spanLoggerGenerator.test.ts.snap

@@ -0,0 +1,1965 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`generateSpanLoggerClass snapshots snapshot: empty schema 1`] = `
+"
+  'use strict';
+
+  // Inline getTimestampNanos for performance (zero function call overhead)
+  // performance.timeOrigin + performance.now() gives epoch milliseconds with sub-ms precision
+  // Convert to microseconds first (safe as Number), then to nanoseconds as BigInt
+  function getTimestampNanos() {
+    const epochMicros = Math.round((performance.timeOrigin + performance.now()) * 1000);
+    return BigInt(epochMicros) * 1000n;
+  }
+
+  
+
+  class GeneratedSpanLogger {
+    constructor(buffer, getBufferWithSpace, scopeInstance) {
+      this._buffer = buffer;
+      this._getBufferWithSpace = getBufferWithSpace;
+      this._scope = scopeInstance;
+    }
+
+    // Tag getter - returns chainable API that writes to row 0 (span-start)
+    // Note: No overflow check needed - row 0 always exists
+    // Note: No writeIndex increment - always writing to same row (overwrite semantics)
+    get tag() {
+      // Entry type for row 0 is already span-start (set at buffer creation)
+      // Just return this for chaining - individual methods write to row 0
+      return this;
+    }
+
+    // with() method for bulk attribute setting - writes to row 0
+    // UNROLLED: Each column gets explicit code, no Object.entries iteration
+    
+    with(attributes) {
+      
+      return this;
+    }
+
+    // Attribute writer methods (generated from schema)
+    
+
+    // Scoped attributes - writes to Scope instance and pre-fills buffer
+    // NOTE: scope() exposed via ctx.scope, but SpanLogger provides _setScope for implementation
+    // UNROLLED: Each column gets explicit TypedArray.fill() + bulk null bitmap
+    
+    _setScope(attributes) {
+      // Update the Scope instance (stores raw values, not interned)
+      
+
+      // Pre-fill remaining buffer capacity with scoped attributes
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+    }
+
+    /**
+     * Pre-fill buffer with scoped attributes from current writeIndex to capacity.
+     * Called after buffer overflow to propagate scoped attributes to the new buffer.
+     *
+     * UNROLLED: Each column gets explicit code with bulk null bitmap operations
+     */
+    
+    _prefillScopedAttributes() {
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+    }
+
+    // Message logging methods
+    // UNROLLED: Scope attribute writes are explicit per-column, no Object.entries
+    
+    _writeMessage(entryType, message) {
+      const result = this._getBufferWithSpace(this._buffer);
+
+      // If overflow occurred, pre-fill new buffer with scoped attributes
+      if (result.didOverflow) {
+        this._buffer = result.buffer;
+        this._prefillScopedAttributes();
+      } else {
+        this._buffer = result.buffer;
+      }
+
+      const idx = this._buffer.writeIndex;
+
+      // Write entry type
+      this._buffer.operations[idx] = entryType;
+
+      // Write timestamp (nanoseconds since epoch)
+      this._buffer.timestamps[idx] = getTimestampNanos();
+
+      // Write message to logMessage column (raw string, no interning)
+      const messageColumn = this._buffer.logMessage_values;
+      if (messageColumn) {
+        messageColumn[idx] = message;
+        helpers.setNullBit(this._buffer.logMessage_nulls, idx);
+      }
+
+      // Apply scoped attributes - UNROLLED per-column
+      
+
+      // Increment write index
+      this._buffer.writeIndex++;
+
+      // Return fluent object for attribute chaining
+      // Capture buffer reference directly (not via self._buffer) so it's stable
+      // even if another log call happens before fluent methods are called
+      const buf = this._buffer;
+      return {
+        line(lineNumber) {
+          const lineCol = buf.lineNumber_values;
+          if (lineCol) {
+            lineCol[idx] = lineNumber;
+            helpers.setNullBit(buf.lineNumber_nulls, idx);
+          }
+          return this;
+        },
+        
+      };
+    }
+    
+    message(level, message) {
+      const entryTypeMap = {
+        'info': 9,
+        'debug': 10,
+        'warn': 11,
+        'error': 12
+      };
+      return this._writeMessage(entryTypeMap[level] || 9, message);
+    }
+    
+    info(message) {
+      return this._writeMessage(9, message);
+    }
+    
+    debug(message) {
+      return this._writeMessage(10, message);
+    }
+    
+    warn(message) {
+      return this._writeMessage(11, message);
+    }
+    
+    error(message) {
+      return this._writeMessage(12, message);
+    }
+
+    // Get the Scope instance directly
+    _getScope() {
+      return this._scope;
+    }
+  }
+
+  return GeneratedSpanLogger;
+"
+`;
+
+exports[`generateSpanLoggerClass snapshots snapshot: all field types 1`] = `
+"
+  'use strict';
+
+  // Inline getTimestampNanos for performance (zero function call overhead)
+  // performance.timeOrigin + performance.now() gives epoch milliseconds with sub-ms precision
+  // Convert to microseconds first (safe as Number), then to nanoseconds as BigInt
+  function getTimestampNanos() {
+    const epochMicros = Math.round((performance.timeOrigin + performance.now()) * 1000);
+    return BigInt(epochMicros) * 1000n;
+  }
+
+  
+  function getEnumIndex_operation(value) {
+    switch(value) {
+    case "CREATE": return 0;
+    case "READ": return 1;
+    case "UPDATE": return 2;
+    case "DELETE": return 3;
+      default: return 0;
+    }
+  }
+
+  class GeneratedSpanLogger {
+    constructor(buffer, getBufferWithSpace, scopeInstance) {
+      this._buffer = buffer;
+      this._getBufferWithSpace = getBufferWithSpace;
+      this._scope = scopeInstance;
+    }
+
+    // Tag getter - returns chainable API that writes to row 0 (span-start)
+    // Note: No overflow check needed - row 0 always exists
+    // Note: No writeIndex increment - always writing to same row (overwrite semantics)
+    get tag() {
+      // Entry type for row 0 is already span-start (set at buffer creation)
+      // Just return this for chaining - individual methods write to row 0
+      return this;
+    }
+
+    // with() method for bulk attribute setting - writes to row 0
+    // UNROLLED: Each column gets explicit code, no Object.entries iteration
+    
+    with(attributes) {
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        this._buffer.userId_values[0] = attributes.userId;
+        this._buffer.userId_nulls[0] |= 1;
+      }
+
+      if ('operation' in attributes && attributes.operation !== null && attributes.operation !== undefined) {
+        this._buffer.operation_values[0] = getEnumIndex_operation(attributes.operation);
+        this._buffer.operation_nulls[0] |= 1;
+      }
+
+      if ('errorMsg' in attributes && attributes.errorMsg !== null && attributes.errorMsg !== undefined) {
+        this._buffer.errorMsg_values[0] = attributes.errorMsg;
+        this._buffer.errorMsg_nulls[0] |= 1;
+      }
+
+      if ('count' in attributes && attributes.count !== null && attributes.count !== undefined) {
+        this._buffer.count_values[0] = attributes.count;
+        this._buffer.count_nulls[0] |= 1;
+      }
+
+      if ('enabled' in attributes && attributes.enabled !== null && attributes.enabled !== undefined) {
+        // Bit-packed boolean write at index 0
+        if (attributes.enabled) {
+          this._buffer.enabled_values[0] |= 1;
+        } else {
+          this._buffer.enabled_values[0] &= ~1;
+        }
+        this._buffer.enabled_nulls[0] |= 1;
+      }
+      return this;
+    }
+
+    // Attribute writer methods (generated from schema)
+    
+    userId(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      this._buffer.userId_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.userId_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    operation(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      const enumIndex = getEnumIndex_operation(value);
+      this._buffer.operation_values[idx] = enumIndex;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.operation_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    errorMsg(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      const nullBitmap = this._buffer.errorMsg_nulls;
+
+      // Handle null/undefined: clear null bitmap bit and return early
+      if (value === null || value === undefined) {
+        if (nullBitmap) {
+          nullBitmap[0] &= ~1;  // Clear bit 0
+        }
+        return this;
+      }
+
+      // Store the text value (raw string, no interning)
+      this._buffer.errorMsg_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    count(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      this._buffer.count_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.count_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    enabled(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      // Bit-packed: bit 0 of byte 0 is index 0
+      if (value) {
+        this._buffer.enabled_values[0] |= 1;
+      } else {
+        this._buffer.enabled_values[0] &= ~1;
+      }
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.enabled_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    // Scoped attributes - writes to Scope instance and pre-fills buffer
+    // NOTE: scope() exposed via ctx.scope, but SpanLogger provides _setScope for implementation
+    // UNROLLED: Each column gets explicit TypedArray.fill() + bulk null bitmap
+    
+    _setScope(attributes) {
+      // Update the Scope instance (stores raw values, not interned)
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        this._scope.userId = attributes.userId;
+      }
+
+      if ('operation' in attributes && attributes.operation !== null && attributes.operation !== undefined) {
+        this._scope.operation = attributes.operation;
+      }
+
+      if ('errorMsg' in attributes && attributes.errorMsg !== null && attributes.errorMsg !== undefined) {
+        this._scope.errorMsg = attributes.errorMsg;
+      }
+
+      if ('count' in attributes && attributes.count !== null && attributes.count !== undefined) {
+        this._scope.count = attributes.count;
+      }
+
+      if ('enabled' in attributes && attributes.enabled !== null && attributes.enabled !== undefined) {
+        this._scope.enabled = attributes.enabled;
+      }
+
+      // Pre-fill remaining buffer capacity with scoped attributes
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        // Fill string array with manual loop
+        const values = this._buffer.userId_values;
+        for (let i = startIdx; i < endIdx; i++) {
+          values[i] = attributes.userId;
+        }
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.userId_nulls, startIdx, endIdx);
+      }
+
+      if ('operation' in attributes && attributes.operation !== null && attributes.operation !== undefined) {
+        // Fill values with SIMD-friendly TypedArray.fill()
+        this._buffer.operation_values.fill(getEnumIndex_operation(attributes.operation), startIdx, endIdx);
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.operation_nulls, startIdx, endIdx);
+      }
+
+      if ('errorMsg' in attributes && attributes.errorMsg !== null && attributes.errorMsg !== undefined) {
+        // Fill string array with manual loop
+        const values = this._buffer.errorMsg_values;
+        for (let i = startIdx; i < endIdx; i++) {
+          values[i] = attributes.errorMsg;
+        }
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.errorMsg_nulls, startIdx, endIdx);
+      }
+
+      if ('count' in attributes && attributes.count !== null && attributes.count !== undefined) {
+        // Fill values with SIMD-friendly TypedArray.fill()
+        this._buffer.count_values.fill(attributes.count, startIdx, endIdx);
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.count_nulls, startIdx, endIdx);
+      }
+
+      if ('enabled' in attributes && attributes.enabled !== null && attributes.enabled !== undefined) {
+        helpers.fillBooleanBitmapRange(this._buffer.enabled_values, startIdx, endIdx, attributes.enabled);
+        helpers.fillNullBitmapRange(this._buffer.enabled_nulls, startIdx, endIdx);
+      }
+    }
+
+    /**
+     * Pre-fill buffer with scoped attributes from current writeIndex to capacity.
+     * Called after buffer overflow to propagate scoped attributes to the new buffer.
+     *
+     * UNROLLED: Each column gets explicit code with bulk null bitmap operations
+     */
+    
+    _prefillScopedAttributes() {
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      {
+        const scopeValue = this._scope.userId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill string array with manual loop
+          const values = this._buffer.userId_values;
+          for (let i = startIdx; i < endIdx; i++) {
+            values[i] = scopeValue;
+          }
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.userId_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.operation;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill values with SIMD-friendly TypedArray.fill()
+          this._buffer.operation_values.fill(getEnumIndex_operation(scopeValue), startIdx, endIdx);
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.operation_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.errorMsg;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill string array with manual loop
+          const values = this._buffer.errorMsg_values;
+          for (let i = startIdx; i < endIdx; i++) {
+            values[i] = scopeValue;
+          }
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.errorMsg_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.count;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill values with SIMD-friendly TypedArray.fill()
+          this._buffer.count_values.fill(scopeValue, startIdx, endIdx);
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.count_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.enabled;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          helpers.fillBooleanBitmapRange(this._buffer.enabled_values, startIdx, endIdx, scopeValue);
+          helpers.fillNullBitmapRange(this._buffer.enabled_nulls, startIdx, endIdx);
+        }
+      }
+    }
+
+    // Message logging methods
+    // UNROLLED: Scope attribute writes are explicit per-column, no Object.entries
+    
+    _writeMessage(entryType, message) {
+      const result = this._getBufferWithSpace(this._buffer);
+
+      // If overflow occurred, pre-fill new buffer with scoped attributes
+      if (result.didOverflow) {
+        this._buffer = result.buffer;
+        this._prefillScopedAttributes();
+      } else {
+        this._buffer = result.buffer;
+      }
+
+      const idx = this._buffer.writeIndex;
+
+      // Write entry type
+      this._buffer.operations[idx] = entryType;
+
+      // Write timestamp (nanoseconds since epoch)
+      this._buffer.timestamps[idx] = getTimestampNanos();
+
+      // Write message to logMessage column (raw string, no interning)
+      const messageColumn = this._buffer.logMessage_values;
+      if (messageColumn) {
+        messageColumn[idx] = message;
+        helpers.setNullBit(this._buffer.logMessage_nulls, idx);
+      }
+
+      // Apply scoped attributes - UNROLLED per-column
+      
+      {
+        const scopeValue = this._scope.userId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.userId_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.userId_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.operation;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.operation_values[idx] = getEnumIndex_operation(scopeValue);
+          helpers.setNullBit(this._buffer.operation_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.errorMsg;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.errorMsg_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.errorMsg_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.count;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.count_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.count_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.enabled;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          const byteIndex = idx >>> 3;
+          const bitOffset = idx & 7;
+          // Bit-packed boolean write
+          if (scopeValue) {
+            this._buffer.enabled_values[byteIndex] |= (1 << bitOffset);
+          } else {
+            this._buffer.enabled_values[byteIndex] &= ~(1 << bitOffset);
+          }
+          helpers.setNullBit(this._buffer.enabled_nulls, idx);
+        }
+      }
+
+      // Increment write index
+      this._buffer.writeIndex++;
+
+      // Return fluent object for attribute chaining
+      // Capture buffer reference directly (not via self._buffer) so it's stable
+      // even if another log call happens before fluent methods are called
+      const buf = this._buffer;
+      return {
+        line(lineNumber) {
+          const lineCol = buf.lineNumber_values;
+          if (lineCol) {
+            lineCol[idx] = lineNumber;
+            helpers.setNullBit(buf.lineNumber_nulls, idx);
+          }
+          return this;
+        },
+        
+        userId(value) {
+          buf.userId_values[idx] = value;
+          helpers.setNullBit(buf.userId_nulls, idx);
+          return this;
+        },
+
+        operation(value) {
+          buf.operation_values[idx] = getEnumIndex_operation(value);
+          helpers.setNullBit(buf.operation_nulls, idx);
+          return this;
+        },
+
+        errorMsg(value) {
+          buf.errorMsg_values[idx] = value;
+          helpers.setNullBit(buf.errorMsg_nulls, idx);
+          return this;
+        },
+
+        count(value) {
+          buf.count_values[idx] = value;
+          helpers.setNullBit(buf.count_nulls, idx);
+          return this;
+        },
+
+        enabled(value) {
+          const byteIndex = idx >>> 3;
+          const bitOffset = idx & 7;
+          if (value) {
+            buf.enabled_values[byteIndex] |= (1 << bitOffset);
+          } else {
+            buf.enabled_values[byteIndex] &= ~(1 << bitOffset);
+          }
+          helpers.setNullBit(buf.enabled_nulls, idx);
+          return this;
+        }
+      };
+    }
+    
+    message(level, message) {
+      const entryTypeMap = {
+        'info': 9,
+        'debug': 10,
+        'warn': 11,
+        'error': 12
+      };
+      return this._writeMessage(entryTypeMap[level] || 9, message);
+    }
+    
+    info(message) {
+      return this._writeMessage(9, message);
+    }
+    
+    debug(message) {
+      return this._writeMessage(10, message);
+    }
+    
+    warn(message) {
+      return this._writeMessage(11, message);
+    }
+    
+    error(message) {
+      return this._writeMessage(12, message);
+    }
+
+    // Get the Scope instance directly
+    _getScope() {
+      return this._scope;
+    }
+  }
+
+  return GeneratedSpanLogger;
+"
+`;
+
+exports[`generateSpanLoggerClass snapshots snapshot: enum with many values 1`] = `
+"
+  'use strict';
+
+  // Inline getTimestampNanos for performance (zero function call overhead)
+  // performance.timeOrigin + performance.now() gives epoch milliseconds with sub-ms precision
+  // Convert to microseconds first (safe as Number), then to nanoseconds as BigInt
+  function getTimestampNanos() {
+    const epochMicros = Math.round((performance.timeOrigin + performance.now()) * 1000);
+    return BigInt(epochMicros) * 1000n;
+  }
+
+  
+  function getEnumIndex_httpMethod(value) {
+    switch(value) {
+    case "GET": return 0;
+    case "POST": return 1;
+    case "PUT": return 2;
+    case "PATCH": return 3;
+    case "DELETE": return 4;
+    case "HEAD": return 5;
+    case "OPTIONS": return 6;
+      default: return 0;
+    }
+  }
+
+  function getEnumIndex_status(value) {
+    switch(value) {
+    case "pending": return 0;
+    case "active": return 1;
+    case "completed": return 2;
+    case "failed": return 3;
+    case "cancelled": return 4;
+      default: return 0;
+    }
+  }
+
+  class GeneratedSpanLogger {
+    constructor(buffer, getBufferWithSpace, scopeInstance) {
+      this._buffer = buffer;
+      this._getBufferWithSpace = getBufferWithSpace;
+      this._scope = scopeInstance;
+    }
+
+    // Tag getter - returns chainable API that writes to row 0 (span-start)
+    // Note: No overflow check needed - row 0 always exists
+    // Note: No writeIndex increment - always writing to same row (overwrite semantics)
+    get tag() {
+      // Entry type for row 0 is already span-start (set at buffer creation)
+      // Just return this for chaining - individual methods write to row 0
+      return this;
+    }
+
+    // with() method for bulk attribute setting - writes to row 0
+    // UNROLLED: Each column gets explicit code, no Object.entries iteration
+    
+    with(attributes) {
+      
+      if ('httpMethod' in attributes && attributes.httpMethod !== null && attributes.httpMethod !== undefined) {
+        this._buffer.httpMethod_values[0] = getEnumIndex_httpMethod(attributes.httpMethod);
+        this._buffer.httpMethod_nulls[0] |= 1;
+      }
+
+      if ('status' in attributes && attributes.status !== null && attributes.status !== undefined) {
+        this._buffer.status_values[0] = getEnumIndex_status(attributes.status);
+        this._buffer.status_nulls[0] |= 1;
+      }
+      return this;
+    }
+
+    // Attribute writer methods (generated from schema)
+    
+    httpMethod(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      const enumIndex = getEnumIndex_httpMethod(value);
+      this._buffer.httpMethod_values[idx] = enumIndex;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.httpMethod_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    status(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      const enumIndex = getEnumIndex_status(value);
+      this._buffer.status_values[idx] = enumIndex;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.status_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    // Scoped attributes - writes to Scope instance and pre-fills buffer
+    // NOTE: scope() exposed via ctx.scope, but SpanLogger provides _setScope for implementation
+    // UNROLLED: Each column gets explicit TypedArray.fill() + bulk null bitmap
+    
+    _setScope(attributes) {
+      // Update the Scope instance (stores raw values, not interned)
+      
+      if ('httpMethod' in attributes && attributes.httpMethod !== null && attributes.httpMethod !== undefined) {
+        this._scope.httpMethod = attributes.httpMethod;
+      }
+
+      if ('status' in attributes && attributes.status !== null && attributes.status !== undefined) {
+        this._scope.status = attributes.status;
+      }
+
+      // Pre-fill remaining buffer capacity with scoped attributes
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      if ('httpMethod' in attributes && attributes.httpMethod !== null && attributes.httpMethod !== undefined) {
+        // Fill values with SIMD-friendly TypedArray.fill()
+        this._buffer.httpMethod_values.fill(getEnumIndex_httpMethod(attributes.httpMethod), startIdx, endIdx);
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.httpMethod_nulls, startIdx, endIdx);
+      }
+
+      if ('status' in attributes && attributes.status !== null && attributes.status !== undefined) {
+        // Fill values with SIMD-friendly TypedArray.fill()
+        this._buffer.status_values.fill(getEnumIndex_status(attributes.status), startIdx, endIdx);
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.status_nulls, startIdx, endIdx);
+      }
+    }
+
+    /**
+     * Pre-fill buffer with scoped attributes from current writeIndex to capacity.
+     * Called after buffer overflow to propagate scoped attributes to the new buffer.
+     *
+     * UNROLLED: Each column gets explicit code with bulk null bitmap operations
+     */
+    
+    _prefillScopedAttributes() {
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      {
+        const scopeValue = this._scope.httpMethod;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill values with SIMD-friendly TypedArray.fill()
+          this._buffer.httpMethod_values.fill(getEnumIndex_httpMethod(scopeValue), startIdx, endIdx);
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.httpMethod_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.status;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill values with SIMD-friendly TypedArray.fill()
+          this._buffer.status_values.fill(getEnumIndex_status(scopeValue), startIdx, endIdx);
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.status_nulls, startIdx, endIdx);
+        }
+      }
+    }
+
+    // Message logging methods
+    // UNROLLED: Scope attribute writes are explicit per-column, no Object.entries
+    
+    _writeMessage(entryType, message) {
+      const result = this._getBufferWithSpace(this._buffer);
+
+      // If overflow occurred, pre-fill new buffer with scoped attributes
+      if (result.didOverflow) {
+        this._buffer = result.buffer;
+        this._prefillScopedAttributes();
+      } else {
+        this._buffer = result.buffer;
+      }
+
+      const idx = this._buffer.writeIndex;
+
+      // Write entry type
+      this._buffer.operations[idx] = entryType;
+
+      // Write timestamp (nanoseconds since epoch)
+      this._buffer.timestamps[idx] = getTimestampNanos();
+
+      // Write message to logMessage column (raw string, no interning)
+      const messageColumn = this._buffer.logMessage_values;
+      if (messageColumn) {
+        messageColumn[idx] = message;
+        helpers.setNullBit(this._buffer.logMessage_nulls, idx);
+      }
+
+      // Apply scoped attributes - UNROLLED per-column
+      
+      {
+        const scopeValue = this._scope.httpMethod;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.httpMethod_values[idx] = getEnumIndex_httpMethod(scopeValue);
+          helpers.setNullBit(this._buffer.httpMethod_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.status;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.status_values[idx] = getEnumIndex_status(scopeValue);
+          helpers.setNullBit(this._buffer.status_nulls, idx);
+        }
+      }
+
+      // Increment write index
+      this._buffer.writeIndex++;
+
+      // Return fluent object for attribute chaining
+      // Capture buffer reference directly (not via self._buffer) so it's stable
+      // even if another log call happens before fluent methods are called
+      const buf = this._buffer;
+      return {
+        line(lineNumber) {
+          const lineCol = buf.lineNumber_values;
+          if (lineCol) {
+            lineCol[idx] = lineNumber;
+            helpers.setNullBit(buf.lineNumber_nulls, idx);
+          }
+          return this;
+        },
+        
+        httpMethod(value) {
+          buf.httpMethod_values[idx] = getEnumIndex_httpMethod(value);
+          helpers.setNullBit(buf.httpMethod_nulls, idx);
+          return this;
+        },
+
+        status(value) {
+          buf.status_values[idx] = getEnumIndex_status(value);
+          helpers.setNullBit(buf.status_nulls, idx);
+          return this;
+        }
+      };
+    }
+    
+    message(level, message) {
+      const entryTypeMap = {
+        'info': 9,
+        'debug': 10,
+        'warn': 11,
+        'error': 12
+      };
+      return this._writeMessage(entryTypeMap[level] || 9, message);
+    }
+    
+    info(message) {
+      return this._writeMessage(9, message);
+    }
+    
+    debug(message) {
+      return this._writeMessage(10, message);
+    }
+    
+    warn(message) {
+      return this._writeMessage(11, message);
+    }
+    
+    error(message) {
+      return this._writeMessage(12, message);
+    }
+
+    // Get the Scope instance directly
+    _getScope() {
+      return this._scope;
+    }
+  }
+
+  return GeneratedSpanLogger;
+"
+`;
+
+exports[`generateSpanLoggerClass snapshots snapshot: category and text fields 1`] = `
+"
+  'use strict';
+
+  // Inline getTimestampNanos for performance (zero function call overhead)
+  // performance.timeOrigin + performance.now() gives epoch milliseconds with sub-ms precision
+  // Convert to microseconds first (safe as Number), then to nanoseconds as BigInt
+  function getTimestampNanos() {
+    const epochMicros = Math.round((performance.timeOrigin + performance.now()) * 1000);
+    return BigInt(epochMicros) * 1000n;
+  }
+
+  
+
+  class GeneratedSpanLogger {
+    constructor(buffer, getBufferWithSpace, scopeInstance) {
+      this._buffer = buffer;
+      this._getBufferWithSpace = getBufferWithSpace;
+      this._scope = scopeInstance;
+    }
+
+    // Tag getter - returns chainable API that writes to row 0 (span-start)
+    // Note: No overflow check needed - row 0 always exists
+    // Note: No writeIndex increment - always writing to same row (overwrite semantics)
+    get tag() {
+      // Entry type for row 0 is already span-start (set at buffer creation)
+      // Just return this for chaining - individual methods write to row 0
+      return this;
+    }
+
+    // with() method for bulk attribute setting - writes to row 0
+    // UNROLLED: Each column gets explicit code, no Object.entries iteration
+    
+    with(attributes) {
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        this._buffer.userId_values[0] = attributes.userId;
+        this._buffer.userId_nulls[0] |= 1;
+      }
+
+      if ('sessionId' in attributes && attributes.sessionId !== null && attributes.sessionId !== undefined) {
+        this._buffer.sessionId_values[0] = attributes.sessionId;
+        this._buffer.sessionId_nulls[0] |= 1;
+      }
+
+      if ('requestBody' in attributes && attributes.requestBody !== null && attributes.requestBody !== undefined) {
+        this._buffer.requestBody_values[0] = attributes.requestBody;
+        this._buffer.requestBody_nulls[0] |= 1;
+      }
+
+      if ('errorMessage' in attributes && attributes.errorMessage !== null && attributes.errorMessage !== undefined) {
+        this._buffer.errorMessage_values[0] = attributes.errorMessage;
+        this._buffer.errorMessage_nulls[0] |= 1;
+      }
+      return this;
+    }
+
+    // Attribute writer methods (generated from schema)
+    
+    userId(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      this._buffer.userId_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.userId_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    sessionId(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      this._buffer.sessionId_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.sessionId_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    requestBody(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      const nullBitmap = this._buffer.requestBody_nulls;
+
+      // Handle null/undefined: clear null bitmap bit and return early
+      if (value === null || value === undefined) {
+        if (nullBitmap) {
+          nullBitmap[0] &= ~1;  // Clear bit 0
+        }
+        return this;
+      }
+
+      // Store the text value (raw string, no interning)
+      this._buffer.requestBody_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    errorMessage(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      const nullBitmap = this._buffer.errorMessage_nulls;
+
+      // Handle null/undefined: clear null bitmap bit and return early
+      if (value === null || value === undefined) {
+        if (nullBitmap) {
+          nullBitmap[0] &= ~1;  // Clear bit 0
+        }
+        return this;
+      }
+
+      // Store the text value (raw string, no interning)
+      this._buffer.errorMessage_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    // Scoped attributes - writes to Scope instance and pre-fills buffer
+    // NOTE: scope() exposed via ctx.scope, but SpanLogger provides _setScope for implementation
+    // UNROLLED: Each column gets explicit TypedArray.fill() + bulk null bitmap
+    
+    _setScope(attributes) {
+      // Update the Scope instance (stores raw values, not interned)
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        this._scope.userId = attributes.userId;
+      }
+
+      if ('sessionId' in attributes && attributes.sessionId !== null && attributes.sessionId !== undefined) {
+        this._scope.sessionId = attributes.sessionId;
+      }
+
+      if ('requestBody' in attributes && attributes.requestBody !== null && attributes.requestBody !== undefined) {
+        this._scope.requestBody = attributes.requestBody;
+      }
+
+      if ('errorMessage' in attributes && attributes.errorMessage !== null && attributes.errorMessage !== undefined) {
+        this._scope.errorMessage = attributes.errorMessage;
+      }
+
+      // Pre-fill remaining buffer capacity with scoped attributes
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        // Fill string array with manual loop
+        const values = this._buffer.userId_values;
+        for (let i = startIdx; i < endIdx; i++) {
+          values[i] = attributes.userId;
+        }
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.userId_nulls, startIdx, endIdx);
+      }
+
+      if ('sessionId' in attributes && attributes.sessionId !== null && attributes.sessionId !== undefined) {
+        // Fill string array with manual loop
+        const values = this._buffer.sessionId_values;
+        for (let i = startIdx; i < endIdx; i++) {
+          values[i] = attributes.sessionId;
+        }
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.sessionId_nulls, startIdx, endIdx);
+      }
+
+      if ('requestBody' in attributes && attributes.requestBody !== null && attributes.requestBody !== undefined) {
+        // Fill string array with manual loop
+        const values = this._buffer.requestBody_values;
+        for (let i = startIdx; i < endIdx; i++) {
+          values[i] = attributes.requestBody;
+        }
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.requestBody_nulls, startIdx, endIdx);
+      }
+
+      if ('errorMessage' in attributes && attributes.errorMessage !== null && attributes.errorMessage !== undefined) {
+        // Fill string array with manual loop
+        const values = this._buffer.errorMessage_values;
+        for (let i = startIdx; i < endIdx; i++) {
+          values[i] = attributes.errorMessage;
+        }
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.errorMessage_nulls, startIdx, endIdx);
+      }
+    }
+
+    /**
+     * Pre-fill buffer with scoped attributes from current writeIndex to capacity.
+     * Called after buffer overflow to propagate scoped attributes to the new buffer.
+     *
+     * UNROLLED: Each column gets explicit code with bulk null bitmap operations
+     */
+    
+    _prefillScopedAttributes() {
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      {
+        const scopeValue = this._scope.userId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill string array with manual loop
+          const values = this._buffer.userId_values;
+          for (let i = startIdx; i < endIdx; i++) {
+            values[i] = scopeValue;
+          }
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.userId_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.sessionId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill string array with manual loop
+          const values = this._buffer.sessionId_values;
+          for (let i = startIdx; i < endIdx; i++) {
+            values[i] = scopeValue;
+          }
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.sessionId_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.requestBody;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill string array with manual loop
+          const values = this._buffer.requestBody_values;
+          for (let i = startIdx; i < endIdx; i++) {
+            values[i] = scopeValue;
+          }
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.requestBody_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.errorMessage;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill string array with manual loop
+          const values = this._buffer.errorMessage_values;
+          for (let i = startIdx; i < endIdx; i++) {
+            values[i] = scopeValue;
+          }
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.errorMessage_nulls, startIdx, endIdx);
+        }
+      }
+    }
+
+    // Message logging methods
+    // UNROLLED: Scope attribute writes are explicit per-column, no Object.entries
+    
+    _writeMessage(entryType, message) {
+      const result = this._getBufferWithSpace(this._buffer);
+
+      // If overflow occurred, pre-fill new buffer with scoped attributes
+      if (result.didOverflow) {
+        this._buffer = result.buffer;
+        this._prefillScopedAttributes();
+      } else {
+        this._buffer = result.buffer;
+      }
+
+      const idx = this._buffer.writeIndex;
+
+      // Write entry type
+      this._buffer.operations[idx] = entryType;
+
+      // Write timestamp (nanoseconds since epoch)
+      this._buffer.timestamps[idx] = getTimestampNanos();
+
+      // Write message to logMessage column (raw string, no interning)
+      const messageColumn = this._buffer.logMessage_values;
+      if (messageColumn) {
+        messageColumn[idx] = message;
+        helpers.setNullBit(this._buffer.logMessage_nulls, idx);
+      }
+
+      // Apply scoped attributes - UNROLLED per-column
+      
+      {
+        const scopeValue = this._scope.userId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.userId_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.userId_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.sessionId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.sessionId_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.sessionId_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.requestBody;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.requestBody_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.requestBody_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.errorMessage;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.errorMessage_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.errorMessage_nulls, idx);
+        }
+      }
+
+      // Increment write index
+      this._buffer.writeIndex++;
+
+      // Return fluent object for attribute chaining
+      // Capture buffer reference directly (not via self._buffer) so it's stable
+      // even if another log call happens before fluent methods are called
+      const buf = this._buffer;
+      return {
+        line(lineNumber) {
+          const lineCol = buf.lineNumber_values;
+          if (lineCol) {
+            lineCol[idx] = lineNumber;
+            helpers.setNullBit(buf.lineNumber_nulls, idx);
+          }
+          return this;
+        },
+        
+        userId(value) {
+          buf.userId_values[idx] = value;
+          helpers.setNullBit(buf.userId_nulls, idx);
+          return this;
+        },
+
+        sessionId(value) {
+          buf.sessionId_values[idx] = value;
+          helpers.setNullBit(buf.sessionId_nulls, idx);
+          return this;
+        },
+
+        requestBody(value) {
+          buf.requestBody_values[idx] = value;
+          helpers.setNullBit(buf.requestBody_nulls, idx);
+          return this;
+        },
+
+        errorMessage(value) {
+          buf.errorMessage_values[idx] = value;
+          helpers.setNullBit(buf.errorMessage_nulls, idx);
+          return this;
+        }
+      };
+    }
+    
+    message(level, message) {
+      const entryTypeMap = {
+        'info': 9,
+        'debug': 10,
+        'warn': 11,
+        'error': 12
+      };
+      return this._writeMessage(entryTypeMap[level] || 9, message);
+    }
+    
+    info(message) {
+      return this._writeMessage(9, message);
+    }
+    
+    debug(message) {
+      return this._writeMessage(10, message);
+    }
+    
+    warn(message) {
+      return this._writeMessage(11, message);
+    }
+    
+    error(message) {
+      return this._writeMessage(12, message);
+    }
+
+    // Get the Scope instance directly
+    _getScope() {
+      return this._scope;
+    }
+  }
+
+  return GeneratedSpanLogger;
+"
+`;
+
+exports[`generateSpanLoggerClass snapshots snapshot: numeric and boolean fields 1`] = `
+"
+  'use strict';
+
+  // Inline getTimestampNanos for performance (zero function call overhead)
+  // performance.timeOrigin + performance.now() gives epoch milliseconds with sub-ms precision
+  // Convert to microseconds first (safe as Number), then to nanoseconds as BigInt
+  function getTimestampNanos() {
+    const epochMicros = Math.round((performance.timeOrigin + performance.now()) * 1000);
+    return BigInt(epochMicros) * 1000n;
+  }
+
+  
+
+  class GeneratedSpanLogger {
+    constructor(buffer, getBufferWithSpace, scopeInstance) {
+      this._buffer = buffer;
+      this._getBufferWithSpace = getBufferWithSpace;
+      this._scope = scopeInstance;
+    }
+
+    // Tag getter - returns chainable API that writes to row 0 (span-start)
+    // Note: No overflow check needed - row 0 always exists
+    // Note: No writeIndex increment - always writing to same row (overwrite semantics)
+    get tag() {
+      // Entry type for row 0 is already span-start (set at buffer creation)
+      // Just return this for chaining - individual methods write to row 0
+      return this;
+    }
+
+    // with() method for bulk attribute setting - writes to row 0
+    // UNROLLED: Each column gets explicit code, no Object.entries iteration
+    
+    with(attributes) {
+      
+      if ('count' in attributes && attributes.count !== null && attributes.count !== undefined) {
+        this._buffer.count_values[0] = attributes.count;
+        this._buffer.count_nulls[0] |= 1;
+      }
+
+      if ('duration' in attributes && attributes.duration !== null && attributes.duration !== undefined) {
+        this._buffer.duration_values[0] = attributes.duration;
+        this._buffer.duration_nulls[0] |= 1;
+      }
+
+      if ('isValid' in attributes && attributes.isValid !== null && attributes.isValid !== undefined) {
+        // Bit-packed boolean write at index 0
+        if (attributes.isValid) {
+          this._buffer.isValid_values[0] |= 1;
+        } else {
+          this._buffer.isValid_values[0] &= ~1;
+        }
+        this._buffer.isValid_nulls[0] |= 1;
+      }
+
+      if ('isEnabled' in attributes && attributes.isEnabled !== null && attributes.isEnabled !== undefined) {
+        // Bit-packed boolean write at index 0
+        if (attributes.isEnabled) {
+          this._buffer.isEnabled_values[0] |= 1;
+        } else {
+          this._buffer.isEnabled_values[0] &= ~1;
+        }
+        this._buffer.isEnabled_nulls[0] |= 1;
+      }
+      return this;
+    }
+
+    // Attribute writer methods (generated from schema)
+    
+    count(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      this._buffer.count_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.count_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    duration(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      this._buffer.duration_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.duration_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    isValid(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      // Bit-packed: bit 0 of byte 0 is index 0
+      if (value) {
+        this._buffer.isValid_values[0] |= 1;
+      } else {
+        this._buffer.isValid_values[0] &= ~1;
+      }
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.isValid_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    isEnabled(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      // Bit-packed: bit 0 of byte 0 is index 0
+      if (value) {
+        this._buffer.isEnabled_values[0] |= 1;
+      } else {
+        this._buffer.isEnabled_values[0] &= ~1;
+      }
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.isEnabled_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    // Scoped attributes - writes to Scope instance and pre-fills buffer
+    // NOTE: scope() exposed via ctx.scope, but SpanLogger provides _setScope for implementation
+    // UNROLLED: Each column gets explicit TypedArray.fill() + bulk null bitmap
+    
+    _setScope(attributes) {
+      // Update the Scope instance (stores raw values, not interned)
+      
+      if ('count' in attributes && attributes.count !== null && attributes.count !== undefined) {
+        this._scope.count = attributes.count;
+      }
+
+      if ('duration' in attributes && attributes.duration !== null && attributes.duration !== undefined) {
+        this._scope.duration = attributes.duration;
+      }
+
+      if ('isValid' in attributes && attributes.isValid !== null && attributes.isValid !== undefined) {
+        this._scope.isValid = attributes.isValid;
+      }
+
+      if ('isEnabled' in attributes && attributes.isEnabled !== null && attributes.isEnabled !== undefined) {
+        this._scope.isEnabled = attributes.isEnabled;
+      }
+
+      // Pre-fill remaining buffer capacity with scoped attributes
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      if ('count' in attributes && attributes.count !== null && attributes.count !== undefined) {
+        // Fill values with SIMD-friendly TypedArray.fill()
+        this._buffer.count_values.fill(attributes.count, startIdx, endIdx);
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.count_nulls, startIdx, endIdx);
+      }
+
+      if ('duration' in attributes && attributes.duration !== null && attributes.duration !== undefined) {
+        // Fill values with SIMD-friendly TypedArray.fill()
+        this._buffer.duration_values.fill(attributes.duration, startIdx, endIdx);
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.duration_nulls, startIdx, endIdx);
+      }
+
+      if ('isValid' in attributes && attributes.isValid !== null && attributes.isValid !== undefined) {
+        helpers.fillBooleanBitmapRange(this._buffer.isValid_values, startIdx, endIdx, attributes.isValid);
+        helpers.fillNullBitmapRange(this._buffer.isValid_nulls, startIdx, endIdx);
+      }
+
+      if ('isEnabled' in attributes && attributes.isEnabled !== null && attributes.isEnabled !== undefined) {
+        helpers.fillBooleanBitmapRange(this._buffer.isEnabled_values, startIdx, endIdx, attributes.isEnabled);
+        helpers.fillNullBitmapRange(this._buffer.isEnabled_nulls, startIdx, endIdx);
+      }
+    }
+
+    /**
+     * Pre-fill buffer with scoped attributes from current writeIndex to capacity.
+     * Called after buffer overflow to propagate scoped attributes to the new buffer.
+     *
+     * UNROLLED: Each column gets explicit code with bulk null bitmap operations
+     */
+    
+    _prefillScopedAttributes() {
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      {
+        const scopeValue = this._scope.count;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill values with SIMD-friendly TypedArray.fill()
+          this._buffer.count_values.fill(scopeValue, startIdx, endIdx);
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.count_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.duration;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill values with SIMD-friendly TypedArray.fill()
+          this._buffer.duration_values.fill(scopeValue, startIdx, endIdx);
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.duration_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.isValid;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          helpers.fillBooleanBitmapRange(this._buffer.isValid_values, startIdx, endIdx, scopeValue);
+          helpers.fillNullBitmapRange(this._buffer.isValid_nulls, startIdx, endIdx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.isEnabled;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          helpers.fillBooleanBitmapRange(this._buffer.isEnabled_values, startIdx, endIdx, scopeValue);
+          helpers.fillNullBitmapRange(this._buffer.isEnabled_nulls, startIdx, endIdx);
+        }
+      }
+    }
+
+    // Message logging methods
+    // UNROLLED: Scope attribute writes are explicit per-column, no Object.entries
+    
+    _writeMessage(entryType, message) {
+      const result = this._getBufferWithSpace(this._buffer);
+
+      // If overflow occurred, pre-fill new buffer with scoped attributes
+      if (result.didOverflow) {
+        this._buffer = result.buffer;
+        this._prefillScopedAttributes();
+      } else {
+        this._buffer = result.buffer;
+      }
+
+      const idx = this._buffer.writeIndex;
+
+      // Write entry type
+      this._buffer.operations[idx] = entryType;
+
+      // Write timestamp (nanoseconds since epoch)
+      this._buffer.timestamps[idx] = getTimestampNanos();
+
+      // Write message to logMessage column (raw string, no interning)
+      const messageColumn = this._buffer.logMessage_values;
+      if (messageColumn) {
+        messageColumn[idx] = message;
+        helpers.setNullBit(this._buffer.logMessage_nulls, idx);
+      }
+
+      // Apply scoped attributes - UNROLLED per-column
+      
+      {
+        const scopeValue = this._scope.count;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.count_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.count_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.duration;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.duration_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.duration_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.isValid;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          const byteIndex = idx >>> 3;
+          const bitOffset = idx & 7;
+          // Bit-packed boolean write
+          if (scopeValue) {
+            this._buffer.isValid_values[byteIndex] |= (1 << bitOffset);
+          } else {
+            this._buffer.isValid_values[byteIndex] &= ~(1 << bitOffset);
+          }
+          helpers.setNullBit(this._buffer.isValid_nulls, idx);
+        }
+      }
+
+      {
+        const scopeValue = this._scope.isEnabled;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          const byteIndex = idx >>> 3;
+          const bitOffset = idx & 7;
+          // Bit-packed boolean write
+          if (scopeValue) {
+            this._buffer.isEnabled_values[byteIndex] |= (1 << bitOffset);
+          } else {
+            this._buffer.isEnabled_values[byteIndex] &= ~(1 << bitOffset);
+          }
+          helpers.setNullBit(this._buffer.isEnabled_nulls, idx);
+        }
+      }
+
+      // Increment write index
+      this._buffer.writeIndex++;
+
+      // Return fluent object for attribute chaining
+      // Capture buffer reference directly (not via self._buffer) so it's stable
+      // even if another log call happens before fluent methods are called
+      const buf = this._buffer;
+      return {
+        line(lineNumber) {
+          const lineCol = buf.lineNumber_values;
+          if (lineCol) {
+            lineCol[idx] = lineNumber;
+            helpers.setNullBit(buf.lineNumber_nulls, idx);
+          }
+          return this;
+        },
+        
+        count(value) {
+          buf.count_values[idx] = value;
+          helpers.setNullBit(buf.count_nulls, idx);
+          return this;
+        },
+
+        duration(value) {
+          buf.duration_values[idx] = value;
+          helpers.setNullBit(buf.duration_nulls, idx);
+          return this;
+        },
+
+        isValid(value) {
+          const byteIndex = idx >>> 3;
+          const bitOffset = idx & 7;
+          if (value) {
+            buf.isValid_values[byteIndex] |= (1 << bitOffset);
+          } else {
+            buf.isValid_values[byteIndex] &= ~(1 << bitOffset);
+          }
+          helpers.setNullBit(buf.isValid_nulls, idx);
+          return this;
+        },
+
+        isEnabled(value) {
+          const byteIndex = idx >>> 3;
+          const bitOffset = idx & 7;
+          if (value) {
+            buf.isEnabled_values[byteIndex] |= (1 << bitOffset);
+          } else {
+            buf.isEnabled_values[byteIndex] &= ~(1 << bitOffset);
+          }
+          helpers.setNullBit(buf.isEnabled_nulls, idx);
+          return this;
+        }
+      };
+    }
+    
+    message(level, message) {
+      const entryTypeMap = {
+        'info': 9,
+        'debug': 10,
+        'warn': 11,
+        'error': 12
+      };
+      return this._writeMessage(entryTypeMap[level] || 9, message);
+    }
+    
+    info(message) {
+      return this._writeMessage(9, message);
+    }
+    
+    debug(message) {
+      return this._writeMessage(10, message);
+    }
+    
+    warn(message) {
+      return this._writeMessage(11, message);
+    }
+    
+    error(message) {
+      return this._writeMessage(12, message);
+    }
+
+    // Get the Scope instance directly
+    _getScope() {
+      return this._scope;
+    }
+  }
+
+  return GeneratedSpanLogger;
+"
+`;
+
+exports[`generateSpanLoggerClass snapshots snapshot: custom class name 1`] = `
+"
+  'use strict';
+
+  // Inline getTimestampNanos for performance (zero function call overhead)
+  // performance.timeOrigin + performance.now() gives epoch milliseconds with sub-ms precision
+  // Convert to microseconds first (safe as Number), then to nanoseconds as BigInt
+  function getTimestampNanos() {
+    const epochMicros = Math.round((performance.timeOrigin + performance.now()) * 1000);
+    return BigInt(epochMicros) * 1000n;
+  }
+
+  
+
+  class CustomSpanLogger {
+    constructor(buffer, getBufferWithSpace, scopeInstance) {
+      this._buffer = buffer;
+      this._getBufferWithSpace = getBufferWithSpace;
+      this._scope = scopeInstance;
+    }
+
+    // Tag getter - returns chainable API that writes to row 0 (span-start)
+    // Note: No overflow check needed - row 0 always exists
+    // Note: No writeIndex increment - always writing to same row (overwrite semantics)
+    get tag() {
+      // Entry type for row 0 is already span-start (set at buffer creation)
+      // Just return this for chaining - individual methods write to row 0
+      return this;
+    }
+
+    // with() method for bulk attribute setting - writes to row 0
+    // UNROLLED: Each column gets explicit code, no Object.entries iteration
+    
+    with(attributes) {
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        this._buffer.userId_values[0] = attributes.userId;
+        this._buffer.userId_nulls[0] |= 1;
+      }
+      return this;
+    }
+
+    // Attribute writer methods (generated from schema)
+    
+    userId(value) {
+      // ALWAYS write to row 0 (span-start) - overwrite semantics
+      const idx = 0;
+      this._buffer.userId_values[idx] = value;
+
+      // Mark as non-null (bit 0 for idx 0)
+      const nullBitmap = this._buffer.userId_nulls;
+      if (nullBitmap) {
+        nullBitmap[0] |= 1;
+      }
+
+      return this;
+    }
+
+    // Scoped attributes - writes to Scope instance and pre-fills buffer
+    // NOTE: scope() exposed via ctx.scope, but SpanLogger provides _setScope for implementation
+    // UNROLLED: Each column gets explicit TypedArray.fill() + bulk null bitmap
+    
+    _setScope(attributes) {
+      // Update the Scope instance (stores raw values, not interned)
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        this._scope.userId = attributes.userId;
+      }
+
+      // Pre-fill remaining buffer capacity with scoped attributes
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      if ('userId' in attributes && attributes.userId !== null && attributes.userId !== undefined) {
+        // Fill string array with manual loop
+        const values = this._buffer.userId_values;
+        for (let i = startIdx; i < endIdx; i++) {
+          values[i] = attributes.userId;
+        }
+
+        // Bulk fill null bitmap using helper
+        helpers.fillNullBitmapRange(this._buffer.userId_nulls, startIdx, endIdx);
+      }
+    }
+
+    /**
+     * Pre-fill buffer with scoped attributes from current writeIndex to capacity.
+     * Called after buffer overflow to propagate scoped attributes to the new buffer.
+     *
+     * UNROLLED: Each column gets explicit code with bulk null bitmap operations
+     */
+    
+    _prefillScopedAttributes() {
+      const startIdx = this._buffer.writeIndex;
+      const endIdx = this._buffer.capacity;
+
+      
+      {
+        const scopeValue = this._scope.userId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          // Fill string array with manual loop
+          const values = this._buffer.userId_values;
+          for (let i = startIdx; i < endIdx; i++) {
+            values[i] = scopeValue;
+          }
+
+          // Bulk fill null bitmap using helper
+          helpers.fillNullBitmapRange(this._buffer.userId_nulls, startIdx, endIdx);
+        }
+      }
+    }
+
+    // Message logging methods
+    // UNROLLED: Scope attribute writes are explicit per-column, no Object.entries
+    
+    _writeMessage(entryType, message) {
+      const result = this._getBufferWithSpace(this._buffer);
+
+      // If overflow occurred, pre-fill new buffer with scoped attributes
+      if (result.didOverflow) {
+        this._buffer = result.buffer;
+        this._prefillScopedAttributes();
+      } else {
+        this._buffer = result.buffer;
+      }
+
+      const idx = this._buffer.writeIndex;
+
+      // Write entry type
+      this._buffer.operations[idx] = entryType;
+
+      // Write timestamp (nanoseconds since epoch)
+      this._buffer.timestamps[idx] = getTimestampNanos();
+
+      // Write message to logMessage column (raw string, no interning)
+      const messageColumn = this._buffer.logMessage_values;
+      if (messageColumn) {
+        messageColumn[idx] = message;
+        helpers.setNullBit(this._buffer.logMessage_nulls, idx);
+      }
+
+      // Apply scoped attributes - UNROLLED per-column
+      
+      {
+        const scopeValue = this._scope.userId;
+        if (scopeValue !== null && scopeValue !== undefined) {
+          this._buffer.userId_values[idx] = scopeValue;
+          helpers.setNullBit(this._buffer.userId_nulls, idx);
+        }
+      }
+
+      // Increment write index
+      this._buffer.writeIndex++;
+
+      // Return fluent object for attribute chaining
+      // Capture buffer reference directly (not via self._buffer) so it's stable
+      // even if another log call happens before fluent methods are called
+      const buf = this._buffer;
+      return {
+        line(lineNumber) {
+          const lineCol = buf.lineNumber_values;
+          if (lineCol) {
+            lineCol[idx] = lineNumber;
+            helpers.setNullBit(buf.lineNumber_nulls, idx);
+          }
+          return this;
+        },
+        
+        userId(value) {
+          buf.userId_values[idx] = value;
+          helpers.setNullBit(buf.userId_nulls, idx);
+          return this;
+        }
+      };
+    }
+    
+    message(level, message) {
+      const entryTypeMap = {
+        'info': 9,
+        'debug': 10,
+        'warn': 11,
+        'error': 12
+      };
+      return this._writeMessage(entryTypeMap[level] || 9, message);
+    }
+    
+    info(message) {
+      return this._writeMessage(9, message);
+    }
+    
+    debug(message) {
+      return this._writeMessage(10, message);
+    }
+    
+    warn(message) {
+      return this._writeMessage(11, message);
+    }
+    
+    error(message) {
+      return this._writeMessage(12, message);
+    }
+
+    // Get the Scope instance directly
+    _getScope() {
+      return this._scope;
+    }
+  }
+
+  return CustomSpanLogger;
+"
+`;