@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/codegen/spanLoggerGenerator.ts

@@ -17,11 +17,18 @@
  */
 
 import {
+  activeMaterializerMode,
   type ColumnEntry,
-  type ColumnWriter,
   type ColumnWriterExtension,
-  getColumnWriterClass,
+  generateColumnWriterClass,
 } from '@smoothbricks/arrow-builder';
+import {
+  type EnumLookupDescriptor,
+  resolveEnumLookupDescriptor,
+  type SchemaEnumLookupDescriptor,
+} from '../enumMetadata.js';
+import { decodeVocabularyMessage } from '../resolveMessage.js';
+import type { MessageLayoutFamily, MessagePhysicalLayout } from '../runtimeHint.js';
 import {
   ENTRY_TYPE_DEBUG,
   ENTRY_TYPE_ERROR,
@@ -31,10 +38,16 @@ import {
   ENTRY_TYPE_TRACE,
   ENTRY_TYPE_WARN,
 } from '../schema/systemSchema.js';
-import { getEnumValues, getSchemaType } from '../schema/typeGuards.js';
+import { getSchemaType } from '../schema/typeGuards.js';
 import type { InferSchema, LogSchema } from '../schema/types.js';
-
-import type { AnySpanBuffer, SpanBuffer } from '../types.js';
+import type { AnySpanBuffer } from '../types.js';
+import type { VocabularyGeneration } from '../vocabularyRegistry.js';
+import type { WriterState } from './fixedPositionWriterGenerator.js';
+import {
+  materializeSpanLoggerClass,
+  type SpanLoggerColumnMode,
+  type SpanLoggerPlan,
+} from './spanLoggerClosureMaterializer.js';
 
 // =============================================================================
 // SINGLETON HELPERS OBJECT
@@ -47,10 +60,17 @@ import type { AnySpanBuffer, SpanBuffer } from '../types.js';
  * Singleton - same object shared by all generated SpanLogger classes.
  */
 export const SPAN_LOGGER_HELPERS: {
+  normalizeOperationalTemplate: (template: string) => string;
   setNullBit: (bitmap: Uint8Array, idx: number) => void;
+  decodeVocabularyMessage: (generation: VocabularyGeneration, denseIndex: number) => string;
   fillNullBitmapRange: (bitmap: Uint8Array, startIdx: number, endIdx: number) => void;
   fillBooleanBitmapRange: (bitmap: Uint8Array, startIdx: number, endIdx: number, value: boolean) => void;
 } = {
+  normalizeOperationalTemplate: (template: string) => {
+    if (template.indexOf('{{') === -1 && template.indexOf('}}') === -1) return template;
+    return template.replaceAll('{{', '{').replaceAll('}}', '}');
+  },
+  decodeVocabularyMessage,
   setNullBit: (bitmap: Uint8Array, idx: number) => {
     bitmap[idx >>> 3] |= 1 << (idx & 7);
   },
@@ -156,12 +176,17 @@ export const SPAN_LOGGER_HELPERS: {
 export interface BaseSpanLogger<T extends LogSchema> {
   /** Log info-level message */
   info(message: string): FluentLogEntry<T>;
+  info(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   /** Log debug-level message */
   debug(message: string): FluentLogEntry<T>;
   /** Log warning message */
   warn(message: string): FluentLogEntry<T>;
+  warn(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   /** Log error message */
   error(message: string): FluentLogEntry<T>;
+  error(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
+  /** Log trace-level message */
+  trace(message: string): FluentLogEntry<T>;
 }
 
 /**
@@ -188,9 +213,12 @@ export type FluentLogEntry<T extends LogSchema> = {
 
   // Logging methods for continued chaining
   info(message: string): FluentLogEntry<T>;
+  info(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   debug(message: string): FluentLogEntry<T>;
   warn(message: string): FluentLogEntry<T>;
+  warn(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   error(message: string): FluentLogEntry<T>;
+  error(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   trace(message: string): FluentLogEntry<T>;
 } & {
   [K in keyof InferSchema<T>]: (value: InferSchema<T>[K]) => FluentLogEntry<T>;
@@ -207,52 +235,50 @@ export type FluentLogEntry<T extends LogSchema> = {
  * This is the FULL type returned by createSpanLogger().
  * Users see SpanLogger<T> which hides internal methods.
  */
-export type SpanLoggerImpl<T extends LogSchema> = ColumnWriter<T> & {
+export type SpanLoggerImpl<T extends LogSchema> = {
   info(message: string): FluentLogEntry<T>;
+  info(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   debug(message: string): FluentLogEntry<T>;
   warn(message: string): FluentLogEntry<T>;
+  warn(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   error(message: string): FluentLogEntry<T>;
+  error(template: string, fields: Partial<InferSchema<T>>): FluentLogEntry<T>;
   trace(message: string): FluentLogEntry<T>;
+  _infoTemplate(vocabularyIndex: number): FluentLogEntry<T>;
+  _debugTemplate(vocabularyIndex: number): FluentLogEntry<T>;
+  _warnTemplate(vocabularyIndex: number): FluentLogEntry<T>;
+  _errorTemplate(vocabularyIndex: number): FluentLogEntry<T>;
+  _traceTemplate(vocabularyIndex: number): FluentLogEntry<T>;
   readonly scope: Readonly<Record<string, unknown>>;
   _setScope(attributes: ScopeUpdate<T>): void;
+  _prefillScopedAttributesOn(buffer: AnySpanBuffer): void;
+} & {
+  [K in keyof InferSchema<T>]: (value: InferSchema<T>[K]) => FluentLogEntry<T>;
 };
 
+export type SpanLoggerConstructor<T extends LogSchema> = new (state: WriterState) => SpanLoggerImpl<T>;
+
 export type ScopeUpdate<T extends LogSchema> = {
   [K in keyof InferSchema<T>]?: InferSchema<T>[K] | null;
 };
 
-/**
- * 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 override fluent setters for enum fields.
  * These convert string values to numeric indices before writing to the buffer.
  * The buffer expects numeric indices (after the enum map removal change).
  */
-function generateEnumFluentSetters(enumFieldNames: Set<string>): string {
+function generateEnumFluentSetters(
+  enumFields: readonly EnumLookupDescriptor[],
+  enumEncoderNames: Readonly<Record<string, string>>,
+): string {
   const setters: string[] = [];
 
-  for (const fieldName of enumFieldNames) {
+  for (const { fieldName } of enumFields) {
+    const encoderName = enumEncoderNames[fieldName];
     setters.push(`
-    /**
-     * Override fluent setter for ${fieldName} to convert string → index.
-     * Buffer expects numeric index, not string value.
-     */
+    /** Convert the declared enum string to its schema-order index. */
     ${fieldName}(value) {
-      const idx = getEnumIndex_${fieldName}(value);
+      const idx = ${encoderName}(value);
       this._buffer.${fieldName}(this._writeIndex, idx);
       return this;
     }`);
@@ -302,7 +328,7 @@ function generateSetScopeMethod(): string {
  */
 function generatePrefillScopedAttributesMethod(
   schemaFields: readonly ColumnEntry[],
-  enumFieldNames: Set<string>,
+  enumEncoderNames: Readonly<Record<string, string>>,
 ): string {
   const columnFills = schemaFields.map(([fieldName, fieldSchema]) => {
     const columnName = fieldName;
@@ -327,8 +353,9 @@ function generatePrefillScopedAttributesMethod(
 
     // Value processing based on type
     let valueExpr = 'scopeValue';
-    if (lmaoType === 'enum' && enumFieldNames.has(fieldName)) {
-      valueExpr = `getEnumIndex_${fieldName}(scopeValue)`;
+    const enumEncoderName = enumEncoderNames[fieldName];
+    if (lmaoType === 'enum' && enumEncoderName !== undefined) {
+      valueExpr = `${enumEncoderName}(scopeValue)`;
     }
 
     // For string arrays (category/text), use manual loop instead of fill()
@@ -372,30 +399,45 @@ function generatePrefillScopedAttributesMethod(
 /**
  * Build the extension for SpanLogger that extends ColumnWriter
  */
-function buildSpanLoggerExtension(schema: LogSchema): ColumnWriterExtension {
+function buildSpanLoggerExtension(
+  schema: LogSchema,
+  messageLayoutFamily: MessageLayoutFamily,
+  messagePhysicalLayout: MessagePhysicalLayout,
+  eagerColumns: readonly string[],
+  enumLookup: SchemaEnumLookupDescriptor,
+): ColumnWriterExtension {
   const schemaFields = schema._columns;
 
-  // Collect enum mappings
-  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);
-    }
-  }
+  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 methods
   const setScopeMethod = generateSetScopeMethod();
-  const prefillMethod = generatePrefillScopedAttributesMethod(schemaFields, enumFieldNames);
-  const enumFluentSetters = generateEnumFluentSetters(enumFieldNames);
+  const prefillMethod = generatePrefillScopedAttributesMethod(schemaFields, enumEncoderNames);
+  const enumFluentSetters = generateEnumFluentSetters(enumLookup.ordered, enumEncoderNames);
+  const staticMessageWrite = (entryType: number): string => {
+    switch (messagePhysicalLayout) {
+      case 'current':
+        return `const localMessageId = this._state._physicalLayoutPlan.encodeLocalMessage(vocabularyIndex);
+      if (localMessageId === 0) {
+        this._buffer.message_values[idx] = helpers.decodeVocabularyMessage(this._buffer._vocabularyGeneration, vocabularyIndex);
+      } else {
+        this._buffer._messageIds[idx] = localMessageId;
+      }`;
+      case 'specialized':
+        return 'this._buffer._logHeaders[idx] = vocabularyIndex + 1;';
+      case 'packed':
+        return `if (vocabularyIndex > 0x00fffffe) throw new RangeError('Packed message dense index exceeds 0xFFFFFE');
+      this._buffer._rowHeaders[idx] = ((((vocabularyIndex + 1) << 8) | ${entryType}) >>> 0);`;
+    }
+  };
 
   return {
-    constructorParams: '',
+    preallocatedColumns: eagerColumns,
 
     // Entry type constants (inlined from lmao.ts)
     classPreamble: `
@@ -406,109 +448,88 @@ function buildSpanLoggerExtension(schema: LogSchema): ColumnWriterExtension {
   const ENTRY_TYPE_TRACE = ${ENTRY_TYPE_TRACE};
   const ENTRY_TYPE_FF_ACCESS = ${ENTRY_TYPE_FF_ACCESS};
   const ENTRY_TYPE_FF_USAGE = ${ENTRY_TYPE_FF_USAGE};
-
-  ${enumMappings.join('\n')}
-`,
-
-    // SpanLogger starts at writeIndex 1, so first nextRow() makes it 2
-    // (Rows 0 and 1 are reserved for span-start and span-end)
-    // Sync buffer's writeIndex - needed for Arrow conversion
-    constructorCode: `
-      this._writeIndex = 1;
-      this._buffer._writeIndex = 2;
+${enumEncoderBindings.join('\n')}
 `,
 
-    // Check for overflow before writing, switch to overflow buffer if needed.
-    // Overflow when _writeIndex >= capacity (buffer is full, no room for this write).
-    // Buffer.getOrCreateOverflow() handles: stats notification, capacity tuning, buffer creation.
-    // We just need to switch this._buffer and prefill scope on the new buffer.
     methods:
-      `_checkOverflow() {
-      if (this._buffer._writeIndex >= this._buffer._capacity) {
-        this._buffer = this._buffer.getOrCreateOverflow();
-        this._prefillScopedAttributesOn(this._buffer);
+      // The optional fields argument is the untransformed fallback. JavaScript evaluates
+      // the receiver, template, and object initializers before this method runs. Lowered
+      // calls use _infoTemplate/_warnTemplate/_errorTemplate plus direct setters instead.
+      // Context-owned append advances the shared active buffer and returns the literal row.
+      `info(message, fields) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_INFO);
+      ${messageLayoutFamily === 'static-only' ? `throw new TypeError('Dynamic log write reached a static-only callsite plan');` : 'this._buffer.message_values[idx] = helpers.normalizeOperationalTemplate(message);'}
+      if (fields !== undefined) {
+        this.with(fields);
       }
+      return this;
     }
 
-    ` +
-      // Write an info log entry.
-      // writeLogEntry bumps buffer._writeIndex, writes timestamp+entry_type, returns idx.
-      // We sync this._writeIndex so fluent setters write at correct row.
-      `info(message) {
-      this._checkOverflow();
-      const idx = this._buffer._traceRoot.writeLogEntry(this._buffer, ENTRY_TYPE_INFO);
-      this._writeIndex = idx;
-      if (this._buffer.message_values) {
-        this._buffer.message_values[idx] = message;
-        if (this._buffer.message_nulls) {
-          helpers.setNullBit(this._buffer.message_nulls, idx);
-        }
-      }
-      this._buffer.constructor.stats.totalWrites++;
+    _infoTemplate(vocabularyIndex) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_INFO);
+      ${messageLayoutFamily === 'dynamic-only' ? `throw new TypeError('Static log write reached a dynamic-only callsite plan');` : staticMessageWrite(ENTRY_TYPE_INFO)}
       return this;
     }
 
     ` +
       // Write a debug log entry.
       `debug(message) {
-      this._checkOverflow();
-      const idx = this._buffer._traceRoot.writeLogEntry(this._buffer, ENTRY_TYPE_DEBUG);
-      this._writeIndex = idx;
-      if (this._buffer.message_values) {
-        this._buffer.message_values[idx] = message;
-        if (this._buffer.message_nulls) {
-          helpers.setNullBit(this._buffer.message_nulls, idx);
-        }
-      }
-      this._buffer.constructor.stats.totalWrites++;
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_DEBUG);
+      ${messageLayoutFamily === 'static-only' ? `throw new TypeError('Dynamic log write reached a static-only callsite plan');` : 'this._buffer.message_values[idx] = message;'}
+      return this;
+    }
+
+    _debugTemplate(vocabularyIndex) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_DEBUG);
+      ${messageLayoutFamily === 'dynamic-only' ? `throw new TypeError('Static log write reached a dynamic-only callsite plan');` : staticMessageWrite(ENTRY_TYPE_DEBUG)}
       return this;
     }
 
     ` +
       // Write a warn log entry.
-      `warn(message) {
-      this._checkOverflow();
-      const idx = this._buffer._traceRoot.writeLogEntry(this._buffer, ENTRY_TYPE_WARN);
-      this._writeIndex = idx;
-      if (this._buffer.message_values) {
-        this._buffer.message_values[idx] = message;
-        if (this._buffer.message_nulls) {
-          helpers.setNullBit(this._buffer.message_nulls, idx);
-        }
+      `warn(message, fields) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_WARN);
+      ${messageLayoutFamily === 'static-only' ? `throw new TypeError('Dynamic log write reached a static-only callsite plan');` : 'this._buffer.message_values[idx] = helpers.normalizeOperationalTemplate(message);'}
+      if (fields !== undefined) {
+        this.with(fields);
       }
-      this._buffer.constructor.stats.totalWrites++;
+      return this;
+    }
+
+    _warnTemplate(vocabularyIndex) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_WARN);
+      ${messageLayoutFamily === 'dynamic-only' ? `throw new TypeError('Static log write reached a dynamic-only callsite plan');` : staticMessageWrite(ENTRY_TYPE_WARN)}
       return this;
     }
 
     ` +
       // Write an error log entry.
-      `error(message) {
-      this._checkOverflow();
-      const idx = this._buffer._traceRoot.writeLogEntry(this._buffer, ENTRY_TYPE_ERROR);
-      this._writeIndex = idx;
-      if (this._buffer.message_values) {
-        this._buffer.message_values[idx] = message;
-        if (this._buffer.message_nulls) {
-          helpers.setNullBit(this._buffer.message_nulls, idx);
-        }
+      `error(message, fields) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_ERROR);
+      ${messageLayoutFamily === 'static-only' ? `throw new TypeError('Dynamic log write reached a static-only callsite plan');` : 'this._buffer.message_values[idx] = helpers.normalizeOperationalTemplate(message);'}
+      if (fields !== undefined) {
+        this.with(fields);
       }
-      this._buffer.constructor.stats.totalWrites++;
+      return this;
+    }
+
+    _errorTemplate(vocabularyIndex) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_ERROR);
+      ${messageLayoutFamily === 'dynamic-only' ? `throw new TypeError('Static log write reached a dynamic-only callsite plan');` : staticMessageWrite(ENTRY_TYPE_ERROR)}
       return this;
     }
 
     ` +
       // Write a trace log entry.
       `trace(message) {
-      this._checkOverflow();
-      const idx = this._buffer._traceRoot.writeLogEntry(this._buffer, ENTRY_TYPE_TRACE);
-      this._writeIndex = idx;
-      if (this._buffer.message_values) {
-        this._buffer.message_values[idx] = message;
-        if (this._buffer.message_nulls) {
-          helpers.setNullBit(this._buffer.message_nulls, idx);
-        }
-      }
-      this._buffer.constructor.stats.totalWrites++;
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_TRACE);
+      ${messageLayoutFamily === 'static-only' ? `throw new TypeError('Dynamic log write reached a static-only callsite plan');` : 'this._buffer.message_values[idx] = message;'}
+      return this;
+    }
+
+    _traceTemplate(vocabularyIndex) {
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_TRACE);
+      ${messageLayoutFamily === 'dynamic-only' ? `throw new TypeError('Static log write reached a dynamic-only callsite plan');` : staticMessageWrite(ENTRY_TYPE_TRACE)}
       return this;
     }
 
@@ -532,15 +553,8 @@ function buildSpanLoggerExtension(schema: LogSchema): ColumnWriterExtension {
       // Write a feature flag access entry (internal method, not on public type).
       // Called by FeatureFlagEvaluator to log flag access.
       `ffAccess(flagName, value) {
-      this._checkOverflow();
-      const idx = this._buffer._traceRoot.writeLogEntry(this._buffer, ENTRY_TYPE_FF_ACCESS);
-      this._writeIndex = idx;
-      if (this._buffer.message_values) {
-        this._buffer.message_values[idx] = flagName;
-        if (this._buffer.message_nulls) {
-          helpers.setNullBit(this._buffer.message_nulls, idx);
-        }
-      }
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_FF_ACCESS);
+      ${messageLayoutFamily === 'static-only' ? `throw new TypeError('Feature flag write reached a static-only callsite plan');` : 'this._buffer.message_values[idx] = flagName;'}
       if (this._buffer.ff_value_values) {
         const strValue = value === null || value === undefined ? 'null' : String(value);
         this._buffer.ff_value_values[idx] = strValue;
@@ -548,23 +562,14 @@ function buildSpanLoggerExtension(schema: LogSchema): ColumnWriterExtension {
           helpers.setNullBit(this._buffer.ff_value_nulls, idx);
         }
       }
-      this._buffer.constructor.stats.totalWrites++;
     }
 
     ` +
       // Write a feature flag usage entry (internal method, not on public type).
       // Called by FeatureFlagEvaluator to log flag usage.
       `ffUsage(flagName, context) {
-      this._checkOverflow();
-      const idx = this._buffer._traceRoot.writeLogEntry(this._buffer, ENTRY_TYPE_FF_USAGE);
-      this._writeIndex = idx;
-      if (this._buffer.message_values) {
-        this._buffer.message_values[idx] = flagName;
-        if (this._buffer.message_nulls) {
-          helpers.setNullBit(this._buffer.message_nulls, idx);
-        }
-      }
-      this._buffer.constructor.stats.totalWrites++;
+      const idx = this._state._appendWriterEntry(ENTRY_TYPE_FF_USAGE);
+      ${messageLayoutFamily === 'static-only' ? `throw new TypeError('Feature flag write reached a static-only callsite plan');` : 'this._buffer.message_values[idx] = flagName;'}
       if (context) {
         this.with(context);
       }
@@ -648,6 +653,7 @@ function buildSpanLoggerExtension(schema: LogSchema): ColumnWriterExtension {
     // Use singleton helpers object (created once at module load)
     dependencies: {
       helpers: SPAN_LOGGER_HELPERS,
+      enumLookup,
     },
   };
 }
@@ -655,48 +661,112 @@ function buildSpanLoggerExtension(schema: LogSchema): ColumnWriterExtension {
 /**
  * Cache for generated SpanLogger classes per schema.
  */
-const spanLoggerClassCache = new WeakMap<LogSchema, unknown>();
+const spanLoggerClassCache = new WeakMap<LogSchema, Map<string, unknown>>();
 
-function isSpanLoggerConstructor<T extends LogSchema>(
-  value: unknown,
-): value is new (
-  buffer: AnySpanBuffer,
-) => SpanLoggerImpl<T> {
+function isSpanLoggerConstructor<T extends LogSchema>(value: unknown): value is SpanLoggerConstructor<T> {
   return typeof value === 'function';
 }
 
+function generateStateBoundSpanLoggerClass(schema: LogSchema, extension: ColumnWriterExtension): string {
+  const source = generateColumnWriterClass(schema, 'GeneratedSpanLogger', extension);
+  const constructorStart = source.indexOf('    constructor(buffer) {');
+  const firstSetter = schema._columnNames[0];
+  const methodsStart = source.indexOf(
+    firstSetter === undefined ? '\n    info(message, fields) {' : `\n    ${firstSetter}(value) {`,
+    constructorStart,
+  );
+  if (constructorStart < 0 || methodsStart < 0) {
+    throw new Error('Failed to locate generated SpanLogger class boundaries');
+  }
+  const stateConstructor = '    constructor(state) {\n      this._state = state;\n    }\n';
+  return (source.slice(0, constructorStart) + stateConstructor + source.slice(methodsStart + 1))
+    .replaceAll('this._buffer', 'this._state._buffer')
+    .replaceAll('this._writeIndex', '(this._state._buffer._writeIndex - 1)');
+}
+
+/** Compiled materializer: render class source and evaluate it with `new Function`. */
+function compileSpanLoggerClass(
+  schema: LogSchema,
+  messageLayoutFamily: MessageLayoutFamily,
+  messagePhysicalLayout: MessagePhysicalLayout,
+  eagerColumns: readonly string[],
+  enumLookup: SchemaEnumLookupDescriptor,
+): unknown {
+  const extension = buildSpanLoggerExtension(
+    schema,
+    messageLayoutFamily,
+    messagePhysicalLayout,
+    eagerColumns,
+    enumLookup,
+  );
+  const classCode = generateStateBoundSpanLoggerClass(schema, extension).trim();
+  return new Function('helpers', 'enumLookup', classCode)(SPAN_LOGGER_HELPERS, enumLookup);
+}
+
 /**
- * Create SpanLogger class constructor from schema.
- * This is the cold-path function called at module creation time.
- *
- * SpanLogger extends ColumnWriter and adds:
- * - info(), debug(), warn(), error() methods for log entries
- * - _setScope() for setting scoped attributes
- * - _getNextBuffer() override for SpanBuffer creation on overflow
+ * Schema/config -> pure-data plan consumed by the closure-composed (no-eval)
+ * materializer. Mirrors the inputs the compiled renderer bakes into source:
+ * per-column access mode (arrow-builder's buildColumnAccessorPlan semantics),
+ * layout family/physical layout, and the injected singleton dependencies.
+ */
+function buildSpanLoggerPlan(
+  schema: LogSchema,
+  messageLayoutFamily: MessageLayoutFamily,
+  messagePhysicalLayout: MessagePhysicalLayout,
+  eagerColumns: readonly string[],
+  enumLookup: SchemaEnumLookupDescriptor,
+): SpanLoggerPlan {
+  const preallocated = new Set(eagerColumns);
+  const columns = schema._columns.map(([fieldName, fieldSchema]) => {
+    const isEager =
+      typeof fieldSchema === 'object' && fieldSchema !== null && Reflect.get(fieldSchema, '__eager') === true;
+    const mode: SpanLoggerColumnMode = isEager ? 'eager' : preallocated.has(fieldName) ? 'preallocated' : 'lazy';
+    return { name: fieldName, schemaType: getSchemaType(fieldSchema), mode };
+  });
+  return {
+    columns,
+    messageLayoutFamily,
+    messagePhysicalLayout,
+    helpers: SPAN_LOGGER_HELPERS,
+    enumLookup,
+  };
+}
+
+/**
+ * Create the state-only SpanLogger constructor selected for one schema/layout family.
  *
- * Note: Fluent attribute setters are inherited from ColumnWriter and write at _writeIndex.
+ * Selects the materializer via activeMaterializerMode(): the compiled renderer
+ * (string codegen) where `new Function` is allowed, the closure-composed
+ * materializer where it is forbidden (e.g. workerd). Cache keys are
+ * mode-prefixed so a forced override never returns the other mode's class.
  */
 export function createSpanLoggerClass<T extends LogSchema>(
   schema: T,
-): new (
-  buffer: AnySpanBuffer,
-) => SpanLoggerImpl<T> {
-  // Check cache first
-  let SpanLoggerClass = spanLoggerClassCache.get(schema);
+  messageLayoutFamily: MessageLayoutFamily = 'mixed',
+  messagePhysicalLayout: MessagePhysicalLayout = 'current',
+  eagerColumns: readonly string[] = [],
+  enumLookup: SchemaEnumLookupDescriptor = resolveEnumLookupDescriptor(schema),
+): SpanLoggerConstructor<T> {
+  const mode = activeMaterializerMode();
+  const cacheKey = `${mode}:${messageLayoutFamily}:${messagePhysicalLayout}:${eagerColumns.join('\u0000')}`;
+  let familyClasses = spanLoggerClassCache.get(schema);
+  let SpanLoggerClass = familyClasses?.get(cacheKey);
 
   if (!SpanLoggerClass) {
-    const extension = buildSpanLoggerExtension(schema);
-
-    // Use arrow-builder's getColumnWriterClass with our extension
-    const WriterClass = getColumnWriterClass(schema, extension);
-
-    SpanLoggerClass = WriterClass;
+    SpanLoggerClass =
+      mode === 'compiled'
+        ? compileSpanLoggerClass(schema, messageLayoutFamily, messagePhysicalLayout, eagerColumns, enumLookup)
+        : materializeSpanLoggerClass(
+            buildSpanLoggerPlan(schema, messageLayoutFamily, messagePhysicalLayout, eagerColumns, enumLookup),
+          );
 
     if (!isSpanLoggerConstructor<LogSchema>(SpanLoggerClass)) {
       throw new Error('Failed to generate SpanLogger constructor');
     }
 
-    spanLoggerClassCache.set(schema, SpanLoggerClass);
+    familyClasses ??= new Map();
+    familyClasses.set(cacheKey, SpanLoggerClass);
+    spanLoggerClassCache.set(schema, familyClasses);
   }
 
   if (!isSpanLoggerConstructor<T>(SpanLoggerClass)) {
@@ -706,14 +776,8 @@ export function createSpanLoggerClass<T extends LogSchema>(
   return SpanLoggerClass;
 }
 
-/**
- * Create a SpanLogger instance for the given buffer.
- *
- * @param schema - Tag attribute schema
- * @param buffer - SpanBuffer to write to
- */
-export function createSpanLogger<T extends LogSchema>(schema: T, buffer: SpanBuffer<T>): SpanLoggerImpl<T> {
-  const SpanLoggerClass = createSpanLoggerClass(schema);
-  return new SpanLoggerClass(buffer);
+/** Create a SpanLogger bound to an existing SpanContext writer state. */
+export function createSpanLogger<T extends LogSchema>(schema: T, state: WriterState): SpanLoggerImpl<T> {
+  return new (createSpanLoggerClass(schema))(state);
 }
 //#endregion smoo/lmao!n/codegen-spanlogger