@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/codegen/fixedPositionWriterGenerator.ts

@@ -1,50 +1,33 @@
 /**
- * Runtime code generation for TagWriter and ResultWriter classes
+ * Fixed-position TagWriter and ResultWriter classes.
+ *
+ * TagWriter uses source-authored constructors and schema-driven prototype methods so
+ * Hermes can compile the implementation ahead of time. ResultWriter selects between a
+ * compiled renderer (new Function, string-codegen runtimes) and a closure-composed
+ * materializer (workerd-safe, no eval) via activeMaterializerMode().
  *
  * These classes provide fluent setter methods that write to a fixed position in a SpanBuffer:
  * - TagWriter: writes to position 0 (span-start row) via ctx.tag.userId("123")
  * - ResultWriter: writes to position 1 (result row) via ctx.ok(data).userId("123")
  *
- * Both share the same codegen since they only differ in:
- * 1. The fixed position (0 vs 1)
- * 2. ResultWriter has additional _result/_error properties
- *
  * WHY Fixed Positions:
  * - Row 0: span-start entry (written at span creation, attributes set via ctx.tag)
  * - Row 1: span-end entry (written at ctx.ok()/ctx.err(), attributes set via fluent API)
  *
- * Pattern:
- * - Each setter calls this._buffer.columnName(this._pos, value) and returns this
- * - Fluent chaining: ctx.tag.userId("123").requestId("abc")
- * - Zero allocation: returns same object reference
+ * Each wrapper stores only the SpanContext state identity. Setters write through
+ * `state._spanBuffer` to their embedded row and return the same wrapper for fluent chaining.
  */
 
-import { bufferHelpers, type ColumnEntry } from '@smoothbricks/arrow-builder';
-import { getEnumValues, getSchemaType } from '../schema/typeGuards.js';
+import { activeMaterializerMode, bufferHelpers, type ColumnEntry } from '@smoothbricks/arrow-builder';
+import { resolveEnumLookupDescriptor, type SchemaEnumLookupDescriptor } from '../enumMetadata.js';
+import type { MessageLayoutFamily, MessagePhysicalLayout } from '../runtimeHint.js';
 import type { InferSchema, LogSchema } from '../schema/types.js';
+import type { TimestampAppendPrimitive } from '../traceRoot.js';
 import type { AnySpanBuffer } from '../types.js';
 
-/**
- * Extension options for injecting custom code into generated writer classes.
- */
+/** Extension methods injected into a generated fixed-position writer class. */
 export interface FixedPositionWriterExtension {
-  /**
-   * Additional code to add to the constructor (after buffer assignment).
-   * Has access to `this` and constructorParams.
-   */
-  constructorCode?: string;
-
-  /**
-   * Additional methods to add to the class body.
-   */
   methods?: string;
-
-  /**
-   * Constructor parameters beyond buffer.
-   * Added AFTER buffer in the constructor signature.
-   * @example "result, isError"
-   */
-  constructorParams?: string;
 }
 
 /**
@@ -66,105 +49,55 @@ export type TagWriter<T extends LogSchema> = {
   [K in keyof InferSchema<T>]: (value: InferSchema<T>[K]) => TagWriter<T>;
 };
 
-/**
- * ResultWriter interface - fluent setter API for result attributes (row 1)
- *
- * Includes _result and _error properties for accessing the return value or error.
- */
-export type ResultWriter<T extends LogSchema, R = unknown, E = unknown> = {
-  /**
-   * The successful result value (set by ctx.ok(data))
-   */
-  readonly _result: R | undefined;
-
-  /**
-   * The error value (set by ctx.err(error))
-   */
-  readonly _error: E | undefined;
-
-  /**
-   * Whether this is an error result
-   */
-  readonly _isError: boolean;
+/** SpanContext-owned hot writer state shared by logger, tag, and result writers. */
+export interface WriterState {
+  /** Immutable span root used by fixed row 0/1 writers. */
+  readonly _spanBuffer: AnySpanBuffer;
+  /** Mutable active buffer used by append writers and updated on overflow. */
+  _buffer: AnySpanBuffer;
+  /** Plan-bound timestamp append operand retained by the SpanContext. */
+  readonly _appendLogEntry: TimestampAppendPrimitive;
+  readonly _physicalLayoutPlan: {
+    readonly ResultWriterClass: ResultWriterConstructor;
+    readonly enumLookup: SchemaEnumLookupDescriptor;
+  };
+  /** Append one dynamic row, centralizing overflow and active-buffer updates. */
+  _appendWriterEntry(entryType: number): number;
+}
 
-  /**
-   * Bulk set multiple attributes at once.
-   */
+/** Result-row writer with schema-specific fluent setters. */
+export type ResultWriter<T extends LogSchema, R = unknown, E = unknown> = {
+  /** Phantom parameters preserve the public generic contract without duplicating result values. */
+  readonly _resultType?: R;
+  readonly _errorType?: E;
   with(attributes: Partial<InferSchema<T>>): ResultWriter<T, R, E>;
-
-  /**
-   * Set the result-row message (row 1).
-   */
   message(text: string): ResultWriter<T, R, E>;
-
-  /**
-   * Set the result-row source line (row 1).
-   */
   line(lineNumber: number): ResultWriter<T, R, E>;
-  /**
-   * Set the reserved `uint64_value` column for this result row.
-   */
   uint64_value(value: bigint): ResultWriter<T, R, E>;
 } & {
-  /**
-   * Individual attribute setters - each returns `this` for chaining.
-   */
   [K in keyof InferSchema<T>]: (value: InferSchema<T>[K]) => ResultWriter<T, R, E>;
 };
 
-type TagWriterConstructor<T extends LogSchema> = new (buffer: AnySpanBuffer) => TagWriter<T>;
+export type TagWriterConstructor<T extends LogSchema> = new (state: WriterState) => TagWriter<T>;
 
-type ResultWriterConstructor<T extends LogSchema> = new <R = unknown, E = unknown>(
-  buffer: AnySpanBuffer,
-  resultOrError: unknown,
-  isError: boolean,
+export type ResultWriterConstructor = new <T extends LogSchema = LogSchema, R = unknown, E = unknown>(
+  state: WriterState,
 ) => ResultWriter<T, R, E>;
 
 function isTagWriterConstructor<T extends LogSchema>(value: unknown): value is TagWriterConstructor<T> {
   return typeof value === 'function';
 }
 
-function isResultWriterConstructor<T extends LogSchema>(value: unknown): value is ResultWriterConstructor<T> {
+function isResultWriterConstructor(value: unknown): value is ResultWriterConstructor {
   return typeof value === 'function';
 }
 
-/**
- * Generate enum value mapping code.
- * Creates a switch-case statement for compile-time enum mapping.
- */
-function generateEnumMapping(fieldName: string, enumValues: readonly string[]): string {
-  const cases = enumValues.map((value, index) => `    case ${JSON.stringify(value)}: return ${index};`).join('\n');
-
-  return `
-  function getEnumIndex_${fieldName}(value) {
-    switch(value) {
-${cases}
-      default: return 0;
-    }
-  }`;
-}
-
-/**
- * Generate setter method code for a single attribute.
- * Calls this._buffer.columnName(this._pos, value) and returns this.
- */
-function generateSetterMethod(fieldName: string, schema: unknown, hasEnumMapping: boolean): string {
-  const columnName = fieldName;
-  const lmaoType = getSchemaType(schema);
-
-  if (lmaoType === 'enum' && hasEnumMapping) {
-    return `
-    ${fieldName}(value) {
-      this._buffer.${columnName}(this._pos, getEnumIndex_${fieldName}(value));
-      return this;
-    }`;
-  }
-
-  // All other types: direct pass-through to buffer setter
-  // The buffer's setter handles null bitmap and storage details
+/** Generate a state-bound setter for one schema attribute and literal row. */
+function generateSetterMethod(fieldName: string, enumEncoderName: string | undefined, position: number): string {
+  const value = enumEncoderName ? `${enumEncoderName}(value)` : 'value';
   return `
     ${fieldName}(value) {
-      this._buffer.${columnName}(this._pos, value);
+      this._state._spanBuffer.${fieldName}(${position}, ${value});
       return this;
     }`;
 }
@@ -173,14 +106,18 @@ function generateSetterMethod(fieldName: string, schema: unknown, hasEnumMapping
  * Generate with() method code - bulk attribute setting.
  * UNROLLED per-column code for zero Object.entries overhead.
  */
-function generateWithMethod(schemaFields: readonly ColumnEntry[], enumFieldNames: Set<string>): string {
+function generateWithMethod(
+  schemaFields: readonly ColumnEntry[],
+  enumEncoderNames: Readonly<Record<string, string>>,
+  position: number,
+): string {
   const columnWrites = schemaFields.map(([fieldName]) => {
-    const hasEnumMapping = enumFieldNames.has(fieldName);
-    const valueExpr = hasEnumMapping ? `getEnumIndex_${fieldName}(attributes.${fieldName})` : `attributes.${fieldName}`;
+    const enumEncoderName = enumEncoderNames[fieldName];
+    const valueExpr = enumEncoderName ? `${enumEncoderName}(attributes.${fieldName})` : `attributes.${fieldName}`;
 
     return `
       if ('${fieldName}' in attributes && attributes.${fieldName} !== null && attributes.${fieldName} !== undefined) {
-        this._buffer.${fieldName}(this._pos, ${valueExpr});
+        this._state._spanBuffer.${fieldName}(${position}, ${valueExpr});
       }`;
   });
 
@@ -206,47 +143,26 @@ export function generateFixedPositionWriterClass(
   position: number,
   className: string,
   extension?: FixedPositionWriterExtension,
+  eagerColumns: readonly string[] = [],
+  enumLookup: SchemaEnumLookupDescriptor = resolveEnumLookupDescriptor(schema),
 ): string {
   const schemaFields = schema._columns;
+  void eagerColumns;
+  const enumEncoderNames: Record<string, string> = Object.create(null);
+  const enumEncoderBindings = enumLookup.ordered.map(({ fieldName }, index) => {
+    const encoderName = `encodeEnum${index}`;
+    enumEncoderNames[fieldName] = encoderName;
+    return `  const ${encoderName} = enumLookup.byField[${JSON.stringify(fieldName)}].encode;`;
+  });
 
-  // Generate enum mapping functions
-  const enumMappings: string[] = [];
-  const enumFieldNames = new Set<string>();
-
-  for (const [fieldName, fieldSchema] of schemaFields) {
-    const lmaoType = getSchemaType(fieldSchema);
-    const enumValues = getEnumValues(fieldSchema);
-
-    if (lmaoType === 'enum' && enumValues) {
-      enumMappings.push(generateEnumMapping(fieldName, enumValues));
-      enumFieldNames.add(fieldName);
-    }
-  }
-
-  // Generate setter methods
-  const setterMethods = schemaFields.map(([fieldName, fieldSchema]) =>
-    generateSetterMethod(fieldName, fieldSchema, enumFieldNames.has(fieldName)),
+  const setterMethods = schemaFields.map(([fieldName]) =>
+    generateSetterMethod(fieldName, enumEncoderNames[fieldName], position),
   );
 
-  // Generate with() method
-  const withMethod = generateWithMethod(schemaFields, enumFieldNames);
-
-  // Build constructor signature
-  const constructorSignature = extension?.constructorParams ? `buffer, ${extension.constructorParams}` : 'buffer';
+  const withMethod = generateWithMethod(schemaFields, enumEncoderNames, position);
 
-  // Build constructor body
-  // Generated structure: assigns _buffer and _pos, then runs extension constructor code if provided
-  const constructorBody = ['    this._buffer = buffer;', `    this._pos = ${position};`];
-
-  if (extension?.constructorCode) {
-    constructorBody.push('');
-    // Extension constructor code runs after _buffer/_pos assignment
-    const extensionLines = extension.constructorCode
-      .trim()
-      .split('\n')
-      .map((line) => `    ${line.trim()}`);
-    constructorBody.push(...extensionLines);
-  }
+  const constructorSignature = 'state';
+  const constructorBody = ['    this._state = state;'];
 
   // Build extension methods (additional methods injected by the caller)
   const extensionMethods = extension?.methods
@@ -258,15 +174,10 @@ export function generateFixedPositionWriterClass(
         .join('\n')
     : '';
 
-  // Generated class structure:
-  // - constructor: assigns _buffer, _pos, then extension code
-  // - with(): bulk attribute setting method
-  // - Individual setter methods for each schema field
-  // - Extension methods (if any)
+  // Generated class stores only `_state`; every method embeds its fixed row literal.
   const classCode = `
   'use strict';
-
-  ${enumMappings.join('\n')}
+${enumEncoderBindings.join('\n')}
 
   class ${className} {
     constructor(${constructorSignature}) {
@@ -293,35 +204,129 @@ ${extensionMethods}
  * Cache for TagWriter classes (position 0).
  * WeakMap allows garbage collection when schema is no longer referenced.
  */
-const tagWriterClassCache = new WeakMap<LogSchema, unknown>();
+const tagWriterClassCache = new WeakMap<LogSchema, Map<string, unknown>>();
 
 /**
  * Cache for ResultWriter classes (position 1).
  */
-const resultWriterClassCache = new WeakMap<LogSchema, unknown>();
+const resultWriterClassCache = new WeakMap<LogSchema, Map<string, unknown>>();
 
 // ============================================================================
-// TagWriter API
+// Closure-composed materializer internals (no eval; shared by tag/result rows)
 // ============================================================================
 
-/**
- * TagWriter extension - adds the reserved system `uint64_value` writer (row 0).
- */
-const tagWriterExtension: FixedPositionWriterExtension = {
-  methods: `
-uint64_value(value) {
-  this._buffer.uint64_value(this._pos, value);
-  return this;
+interface RuntimeFixedWriter {
+  readonly _state: WriterState;
 }
-`,
-};
 
-/**
- * Generate TagWriter class code for a schema.
- * TagWriter writes to position 0 (span-start row).
- */
-export function generateTagWriterClass(schema: LogSchema): string {
-  return generateFixedPositionWriterClass(schema, 0, 'GeneratedTagWriter', tagWriterExtension);
+interface FixedFieldPlan {
+  readonly fieldName: string;
+  readonly encode: ((value: unknown) => number) | undefined;
+}
+
+/** Invoke one schema-specific SpanBuffer setter without generating source. */
+function writeFixedField(writer: RuntimeFixedWriter, fieldName: string, position: number, value: unknown): void {
+  const buffer = writer._state._spanBuffer;
+  const columnWriter: unknown = Reflect.get(buffer, fieldName);
+  if (typeof columnWriter !== 'function') {
+    throw new TypeError(`SpanBuffer column writer ${JSON.stringify(fieldName)} is not callable`);
+  }
+  columnWriter.call(buffer, position, value);
+}
+
+/** Preserve the generated writer's schema order and enum-binding semantics. */
+function createFixedFieldPlans(schema: LogSchema, enumLookup: SchemaEnumLookupDescriptor): readonly FixedFieldPlan[] {
+  const enumFieldNames = new Set<string>();
+  for (const { fieldName } of enumLookup.ordered) enumFieldNames.add(fieldName);
+
+  return schema._columns.map(([fieldName]) => {
+    if (!enumFieldNames.has(fieldName)) return { fieldName, encode: undefined };
+
+    const descriptor = enumLookup.byField[fieldName];
+    if (!descriptor) {
+      throw new TypeError(`Enum lookup for ${JSON.stringify(fieldName)} is missing`);
+    }
+    return { fieldName, encode: descriptor.encode };
+  });
+}
+
+/** Compiled class members are non-enumerable; every closure-installed member must match. */
+function asClassMemberDescriptor(descriptor: PropertyDescriptor): PropertyDescriptor {
+  descriptor.enumerable = false;
+  return descriptor;
+}
+
+/** Create a class-method descriptor whose function name is the schema field name. */
+function createFieldSetterDescriptor(plan: FixedFieldPlan, position: number): PropertyDescriptor {
+  const encode = plan.encode;
+  const methods = encode
+    ? {
+        [plan.fieldName](this: RuntimeFixedWriter, value: string) {
+          writeFixedField(this, plan.fieldName, position, encode(value));
+          return this;
+        },
+      }
+    : {
+        [plan.fieldName](this: RuntimeFixedWriter, value: unknown) {
+          writeFixedField(this, plan.fieldName, position, value);
+          return this;
+        },
+      };
+  const descriptor = Object.getOwnPropertyDescriptor(methods, plan.fieldName);
+  if (!descriptor) throw new Error(`Failed to create writer setter ${JSON.stringify(plan.fieldName)}`);
+  return asClassMemberDescriptor(descriptor);
+}
+
+/** Install the schema-specific fluent API with class-member-equivalent descriptors. */
+function installFixedWriterMethods(prototype: object, plans: readonly FixedFieldPlan[], position: number): void {
+  const bulkMethods = {
+    with(this: RuntimeFixedWriter, attributes: Readonly<Record<string, unknown>>) {
+      for (const plan of plans) {
+        if (
+          plan.fieldName in attributes &&
+          attributes[plan.fieldName] !== null &&
+          attributes[plan.fieldName] !== undefined
+        ) {
+          const value = attributes[plan.fieldName];
+          writeFixedField(this, plan.fieldName, position, plan.encode ? plan.encode(value) : value);
+        }
+      }
+      return this;
+    },
+    uint64_value(this: RuntimeFixedWriter, value: bigint) {
+      this._state._spanBuffer.uint64_value(position, value);
+      return this;
+    },
+  };
+  const withDescriptor = Object.getOwnPropertyDescriptor(bulkMethods, 'with');
+  if (!withDescriptor) throw new Error('Failed to create writer.with');
+  Object.defineProperty(prototype, 'with', asClassMemberDescriptor(withDescriptor));
+
+  for (const plan of plans) {
+    Object.defineProperty(prototype, plan.fieldName, createFieldSetterDescriptor(plan, position));
+  }
+
+  const uint64Descriptor = Object.getOwnPropertyDescriptor(bulkMethods, 'uint64_value');
+  if (!uint64Descriptor) throw new Error('Failed to create writer.uint64_value');
+  Object.defineProperty(prototype, 'uint64_value', asClassMemberDescriptor(uint64Descriptor));
+}
+
+// ============================================================================
+// TagWriter API
+// ============================================================================
+
+/** Build one source-authored constructor for an existing TagWriter cache key. */
+function createStaticTagWriterConstructor(schema: LogSchema, enumLookup: SchemaEnumLookupDescriptor): unknown {
+  class GeneratedTagWriter {
+    readonly _state: WriterState;
+
+    constructor(state: WriterState) {
+      this._state = state;
+    }
+  }
+
+  installFixedWriterMethods(GeneratedTagWriter.prototype, createFixedFieldPlans(schema, enumLookup), 0);
+  return GeneratedTagWriter;
 }
 
 /**
@@ -330,21 +335,25 @@ export function generateTagWriterClass(schema: LogSchema): string {
  * @param schema - Tag attribute schema
  * @returns TagWriter class constructor
  */
-export function getTagWriterClass<T extends LogSchema>(schema: T): new (buffer: AnySpanBuffer) => TagWriter<T> {
-  let WriterClass = tagWriterClassCache.get(schema);
+export function getTagWriterClass<T extends LogSchema>(
+  schema: T,
+  eagerColumns: readonly string[] = [],
+  enumLookup: SchemaEnumLookupDescriptor = resolveEnumLookupDescriptor(schema),
+): TagWriterConstructor<T> {
+  const cacheKey = eagerColumns.join('\u0000');
+  let classes = tagWriterClassCache.get(schema);
+  let WriterClass = classes?.get(cacheKey);
 
   if (!WriterClass) {
-    const classCode = generateTagWriterClass(schema).trim();
-
-    // Compile with new Function()
-    const factory = new Function('helpers', classCode);
-    WriterClass = factory(bufferHelpers);
+    WriterClass = createStaticTagWriterConstructor(schema, enumLookup);
 
     if (!isTagWriterConstructor<LogSchema>(WriterClass)) {
-      throw new Error('Failed to generate TagWriter constructor');
+      throw new Error('Failed to create TagWriter constructor');
     }
 
-    tagWriterClassCache.set(schema, WriterClass);
+    classes ??= new Map();
+    classes.set(cacheKey, WriterClass);
+    tagWriterClassCache.set(schema, classes);
   }
 
   if (!isTagWriterConstructor<T>(WriterClass)) {
@@ -354,118 +363,193 @@ export function getTagWriterClass<T extends LogSchema>(schema: T): new (buffer:
   return WriterClass;
 }
 
-/**
- * Create a TagWriter instance for a buffer.
- *
- * @param schema - Tag attribute schema
- * @param buffer - SpanBuffer to write to
- * @returns TagWriter instance bound to position 0
- */
-export function createTagWriter<T extends LogSchema>(schema: T, buffer: AnySpanBuffer): TagWriter<T> {
-  const WriterClass = getTagWriterClass(schema);
-  return new WriterClass(buffer);
+/** Create a TagWriter bound to an existing SpanContext writer state. */
+export function createTagWriter<T extends LogSchema>(schema: T, state: WriterState): TagWriter<T> {
+  return new (getTagWriterClass(schema))(state);
 }
 
 // ============================================================================
 // ResultWriter API
 // ============================================================================
 
-/**
- * ResultWriter extension - adds _result, _error, _isError properties
- *
- * Constructor sets _isError, _result, and _error based on the isError flag.
- * Result/error values are already accessible via the properties set in constructor.
- */
-const resultWriterExtension: FixedPositionWriterExtension = {
-  constructorParams: 'resultOrError, isError',
-  constructorCode: `
-    this._isError = isError;
-    if (isError) {
-      this._error = resultOrError;
-      this._result = undefined;
-    } else {
-      this._result = resultOrError;
-      this._error = undefined;
-    }
-  `,
-  methods: `
+/** Result-row system setters, specialized once for the plan's message layout family. */
+function createResultWriterExtension(messageLayoutFamily: MessageLayoutFamily): FixedPositionWriterExtension {
+  const messageWrite =
+    messageLayoutFamily === 'static-only'
+      ? 'this._state._spanBuffer._terminalMessage = text;'
+      : 'this._state._spanBuffer.message_values[1] = text;';
+  return {
+    methods: `
 message(text) {
-  this._buffer.message(this._pos, text);
+  ${messageWrite}
   return this;
 }
 
 line(lineNumber) {
-  this._buffer.line(this._pos, lineNumber);
+  this._state._spanBuffer.line(1, lineNumber);
   return this;
 }
 
 uint64_value(value) {
-  this._buffer.uint64_value(this._pos, value);
+  this._state._spanBuffer.uint64_value(1, value);
   return this;
 }
 `,
-};
+  };
+}
 
 /**
  * Generate ResultWriter class code for a schema.
  * ResultWriter writes to position 1 (result row).
  */
-export function generateResultWriterClass(schema: LogSchema): string {
-  return generateFixedPositionWriterClass(schema, 1, 'GeneratedResultWriter', resultWriterExtension);
+export function generateResultWriterClass(
+  schema: LogSchema,
+  messageLayoutFamily: MessageLayoutFamily = 'mixed',
+  _messagePhysicalLayout: MessagePhysicalLayout = 'current',
+  eagerColumns: readonly string[] = [],
+  enumLookup: SchemaEnumLookupDescriptor = resolveEnumLookupDescriptor(schema),
+): string {
+  return generateFixedPositionWriterClass(
+    schema,
+    1,
+    'GeneratedResultWriter',
+    createResultWriterExtension(messageLayoutFamily),
+    eagerColumns,
+    enumLookup,
+  );
+}
+
+/** Result-row message lane accessor for mixed/dynamic layouts. */
+function messageLaneOf(buffer: AnySpanBuffer): (string | undefined)[] {
+  const lane = buffer.message_values;
+  if (lane === undefined) {
+    throw new TypeError('SpanBuffer has no message_values lane for the result row');
+  }
+  return lane;
+}
+
+/** Install result-row system setters mirroring createResultWriterExtension without source text. */
+function installResultSystemMethods(prototype: object, messageLayoutFamily: MessageLayoutFamily): void {
+  const methods =
+    messageLayoutFamily === 'static-only'
+      ? {
+          message(this: RuntimeFixedWriter, text: string) {
+            this._state._spanBuffer._terminalMessage = text;
+            return this;
+          },
+        }
+      : {
+          message(this: RuntimeFixedWriter, text: string) {
+            messageLaneOf(this._state._spanBuffer)[1] = text;
+            return this;
+          },
+        };
+  const messageDescriptor = Object.getOwnPropertyDescriptor(methods, 'message');
+  if (!messageDescriptor) throw new Error('Failed to create ResultWriter.message');
+  Object.defineProperty(prototype, 'message', asClassMemberDescriptor(messageDescriptor));
+
+  const lineMethods = {
+    line(this: RuntimeFixedWriter, lineNumber: number) {
+      this._state._spanBuffer.line(1, lineNumber);
+      return this;
+    },
+  };
+  const lineDescriptor = Object.getOwnPropertyDescriptor(lineMethods, 'line');
+  if (!lineDescriptor) throw new Error('Failed to create ResultWriter.line');
+  Object.defineProperty(prototype, 'line', asClassMemberDescriptor(lineDescriptor));
+}
+
+/** Assemble a ResultWriter class from closures (workerd-safe: no string codegen). */
+function createClosureResultWriterConstructor(
+  schema: LogSchema,
+  messageLayoutFamily: MessageLayoutFamily,
+  enumLookup: SchemaEnumLookupDescriptor,
+): unknown {
+  class GeneratedResultWriter {
+    readonly _state: WriterState;
+
+    constructor(state: WriterState) {
+      this._state = state;
+    }
+  }
+
+  installFixedWriterMethods(GeneratedResultWriter.prototype, createFixedFieldPlans(schema, enumLookup), 1);
+  installResultSystemMethods(GeneratedResultWriter.prototype, messageLayoutFamily);
+  return GeneratedResultWriter;
+}
+
+/** Compile the rendered result-writer source with new Function (string-codegen runtimes only). */
+function compileResultWriterClass(
+  schema: LogSchema,
+  messageLayoutFamily: MessageLayoutFamily,
+  messagePhysicalLayout: MessagePhysicalLayout,
+  eagerColumns: readonly string[],
+  enumLookup: SchemaEnumLookupDescriptor,
+): unknown {
+  const classCode = generateResultWriterClass(
+    schema,
+    messageLayoutFamily,
+    messagePhysicalLayout,
+    eagerColumns,
+    enumLookup,
+  ).trim();
+
+  const factory = new Function('helpers', 'enumLookup', classCode);
+  return factory(bufferHelpers, enumLookup);
 }
 
 /**
  * Get or create a cached ResultWriter class for a schema.
  *
+ * Selects the compiled or closure-composed materializer via activeMaterializerMode();
+ * cache keys are mode-prefixed so an override flip never returns the wrong kind.
+ *
  * @param schema - Tag attribute schema
  * @returns ResultWriter class constructor
  */
 export function getResultWriterClass<T extends LogSchema>(
   schema: T,
-): new <R = unknown, E = unknown>(
-  buffer: AnySpanBuffer,
-  resultOrError: unknown,
-  isError: boolean,
-) => ResultWriter<T, R, E> {
-  let WriterClass = resultWriterClassCache.get(schema);
+  messageLayoutFamily: MessageLayoutFamily = 'mixed',
+  messagePhysicalLayout: MessagePhysicalLayout = 'current',
+  eagerColumns: readonly string[] = [],
+  enumLookup: SchemaEnumLookupDescriptor = resolveEnumLookupDescriptor(schema),
+): ResultWriterConstructor {
+  const mode = activeMaterializerMode();
+  const cacheKey = `${mode}:${messageLayoutFamily}:${messagePhysicalLayout}:${eagerColumns.join('\u0000')}`;
+  let familyClasses = resultWriterClassCache.get(schema);
+  let WriterClass = familyClasses?.get(cacheKey);
 
   if (!WriterClass) {
-    const classCode = generateResultWriterClass(schema).trim();
-
-    // Compile with new Function()
-    const factory = new Function('helpers', classCode);
-    WriterClass = factory(bufferHelpers);
+    WriterClass =
+      mode === 'compiled'
+        ? compileResultWriterClass(schema, messageLayoutFamily, messagePhysicalLayout, eagerColumns, enumLookup)
+        : createClosureResultWriterConstructor(schema, messageLayoutFamily, enumLookup);
 
-    if (!isResultWriterConstructor<LogSchema>(WriterClass)) {
+    if (!isResultWriterConstructor(WriterClass)) {
       throw new Error('Failed to generate ResultWriter constructor');
     }
 
-    resultWriterClassCache.set(schema, WriterClass);
+    familyClasses ??= new Map();
+    familyClasses.set(cacheKey, WriterClass);
+    resultWriterClassCache.set(schema, familyClasses);
   }
 
-  if (!isResultWriterConstructor<T>(WriterClass)) {
+  if (!isResultWriterConstructor(WriterClass)) {
     throw new Error('Invalid cached ResultWriter constructor');
   }
 
   return WriterClass;
 }
 
-/**
- * Create a ResultWriter instance for a buffer.
- *
- * @param schema - Tag attribute schema
- * @param buffer - SpanBuffer to write to
- * @param resultOrError - The result value or error
- * @param isError - Whether this is an error result
- * @returns ResultWriter instance bound to position 1
- */
+/** Create a ResultWriter bound to an existing SpanContext writer state. */
 export function createResultWriter<T extends LogSchema, R = unknown, E = unknown>(
   schema: T,
-  buffer: AnySpanBuffer,
-  resultOrError: R | E,
-  isError: boolean,
+  state: WriterState,
 ): ResultWriter<T, R, E> {
-  const WriterClass = getResultWriterClass(schema);
-  return new WriterClass(buffer, resultOrError, isError);
+  return new (getResultWriterClass(
+    schema,
+    state._spanBuffer._messageLayoutFamily,
+    state._spanBuffer._messagePhysicalLayout,
+  ))<T, R, E>(state);
 }
 //#endregion smoo/lmao!n/codegen-architecture