@smoothbricks/lmao 0.2.2 → 0.2.3

package/dist/lib/codegen/fixedPositionWriterGenerator.js

@@ -1,64 +1,36 @@
 /**
- * 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 } from '@smoothbricks/arrow-builder';
-import { getEnumValues, getSchemaType } from '../schema/typeGuards.js';
+import { activeMaterializerMode, bufferHelpers } from '@smoothbricks/arrow-builder';
+import { resolveEnumLookupDescriptor } from '../enumMetadata.js';
 function isTagWriterConstructor(value) {
     return typeof value === 'function';
 }
 function isResultWriterConstructor(value) {
     return typeof value === 'function';
 }
-/**
- * Generate enum value mapping code.
- * Creates a switch-case statement for compile-time enum mapping.
- */
-function generateEnumMapping(fieldName, enumValues) {
-    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, schema, hasEnumMapping) {
-    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, enumEncoderName, position) {
+    const value = enumEncoderName ? `${enumEncoderName}(value)` : 'value';
     return `
     ${fieldName}(value) {
-      this._buffer.${columnName}(this._pos, value);
+      this._state._spanBuffer.${fieldName}(${position}, ${value});
       return this;
     }`;
 }
@@ -66,13 +38,13 @@ function generateSetterMethod(fieldName, schema, hasEnumMapping) {
  * Generate with() method code - bulk attribute setting.
  * UNROLLED per-column code for zero Object.entries overhead.
  */
-function generateWithMethod(schemaFields, enumFieldNames) {
+function generateWithMethod(schemaFields, enumEncoderNames, position) {
     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});
       }`;
     });
     return `
@@ -91,37 +63,19 @@ function generateWithMethod(schemaFields, enumFieldNames) {
  * @param extension - Optional extension for constructor code, methods, params
  * @returns JavaScript code string for the class
  */
-export function generateFixedPositionWriterClass(schema, position, className, extension) {
+export function generateFixedPositionWriterClass(schema, position, className, extension, eagerColumns = [], enumLookup = resolveEnumLookupDescriptor(schema)) {
     const schemaFields = schema._columns;
-    // Generate enum mapping functions
-    const enumMappings = [];
-    const enumFieldNames = new Set();
-    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)));
-    // Generate with() method
-    const withMethod = generateWithMethod(schemaFields, enumFieldNames);
-    // Build constructor signature
-    const constructorSignature = extension?.constructorParams ? `buffer, ${extension.constructorParams}` : 'buffer';
-    // 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);
-    }
+    void eagerColumns;
+    const enumEncoderNames = 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;`;
+    });
+    const setterMethods = schemaFields.map(([fieldName]) => generateSetterMethod(fieldName, enumEncoderNames[fieldName], position));
+    const withMethod = generateWithMethod(schemaFields, enumEncoderNames, position);
+    const constructorSignature = 'state';
+    const constructorBody = ['    this._state = state;'];
     // Build extension methods (additional methods injected by the caller)
     const extensionMethods = extension?.methods
         ? '\n' +
@@ -131,15 +85,10 @@ export function generateFixedPositionWriterClass(schema, position, className, ex
                 .map((line) => `    ${line}`)
                 .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}) {
@@ -168,26 +117,100 @@ const tagWriterClassCache = new WeakMap();
  * Cache for ResultWriter classes (position 1).
  */
 const resultWriterClassCache = new WeakMap();
+/** Invoke one schema-specific SpanBuffer setter without generating source. */
+function writeFixedField(writer, fieldName, position, value) {
+    const buffer = writer._state._spanBuffer;
+    const columnWriter = 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, enumLookup) {
+    const enumFieldNames = new Set();
+    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) {
+    descriptor.enumerable = false;
+    return descriptor;
+}
+/** Create a class-method descriptor whose function name is the schema field name. */
+function createFieldSetterDescriptor(plan, position) {
+    const encode = plan.encode;
+    const methods = encode
+        ? {
+            [plan.fieldName](value) {
+                writeFixedField(this, plan.fieldName, position, encode(value));
+                return this;
+            },
+        }
+        : {
+            [plan.fieldName](value) {
+                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, plans, position) {
+    const bulkMethods = {
+        with(attributes) {
+            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(value) {
+            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
 // ============================================================================
-/**
- * TagWriter extension - adds the reserved system `uint64_value` writer (row 0).
- */
-const tagWriterExtension = {
-    methods: `
-uint64_value(value) {
-  this._buffer.uint64_value(this._pos, value);
-  return this;
-}
-`,
-};
-/**
- * Generate TagWriter class code for a schema.
- * TagWriter writes to position 0 (span-start row).
- */
-export function generateTagWriterClass(schema) {
-    return generateFixedPositionWriterClass(schema, 0, 'GeneratedTagWriter', tagWriterExtension);
+/** Build one source-authored constructor for an existing TagWriter cache key. */
+function createStaticTagWriterConstructor(schema, enumLookup) {
+    class GeneratedTagWriter {
+        _state;
+        constructor(state) {
+            this._state = state;
+        }
+    }
+    installFixedWriterMethods(GeneratedTagWriter.prototype, createFixedFieldPlans(schema, enumLookup), 0);
+    return GeneratedTagWriter;
 }
 /**
  * Get or create a cached TagWriter class for a schema.
@@ -195,113 +218,151 @@ export function generateTagWriterClass(schema) {
  * @param schema - Tag attribute schema
  * @returns TagWriter class constructor
  */
-export function getTagWriterClass(schema) {
-    let WriterClass = tagWriterClassCache.get(schema);
+export function getTagWriterClass(schema, eagerColumns = [], enumLookup = resolveEnumLookupDescriptor(schema)) {
+    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(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(WriterClass)) {
         throw new Error('Invalid cached TagWriter constructor');
     }
     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(schema, buffer) {
-    const WriterClass = getTagWriterClass(schema);
-    return new WriterClass(buffer);
+/** Create a TagWriter bound to an existing SpanContext writer state. */
+export function createTagWriter(schema, state) {
+    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 = {
-    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) {
+    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) {
-    return generateFixedPositionWriterClass(schema, 1, 'GeneratedResultWriter', resultWriterExtension);
+export function generateResultWriterClass(schema, messageLayoutFamily = 'mixed', _messagePhysicalLayout = 'current', eagerColumns = [], enumLookup = resolveEnumLookupDescriptor(schema)) {
+    return generateFixedPositionWriterClass(schema, 1, 'GeneratedResultWriter', createResultWriterExtension(messageLayoutFamily), eagerColumns, enumLookup);
+}
+/** Result-row message lane accessor for mixed/dynamic layouts. */
+function messageLaneOf(buffer) {
+    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, messageLayoutFamily) {
+    const methods = messageLayoutFamily === 'static-only'
+        ? {
+            message(text) {
+                this._state._spanBuffer._terminalMessage = text;
+                return this;
+            },
+        }
+        : {
+            message(text) {
+                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(lineNumber) {
+            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, messageLayoutFamily, enumLookup) {
+    class GeneratedResultWriter {
+        _state;
+        constructor(state) {
+            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, messageLayoutFamily, messagePhysicalLayout, eagerColumns, enumLookup) {
+    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(schema) {
-    let WriterClass = resultWriterClassCache.get(schema);
+export function getResultWriterClass(schema, messageLayoutFamily = 'mixed', messagePhysicalLayout = 'current', eagerColumns = [], enumLookup = resolveEnumLookupDescriptor(schema)) {
+    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(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(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
- */
-export function createResultWriter(schema, buffer, resultOrError, isError) {
-    const WriterClass = getResultWriterClass(schema);
-    return new WriterClass(buffer, resultOrError, isError);
+/** Create a ResultWriter bound to an existing SpanContext writer state. */
+export function createResultWriter(schema, state) {
+    return new (getResultWriterClass(schema, state._spanBuffer._messageLayoutFamily, state._spanBuffer._messagePhysicalLayout))(state);
 }
 //#endregion smoo/lmao!n/codegen-architecture

package/dist/lib/codegen/spanLoggerClosureMaterializer.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Closure-composed (no-eval) materializer for state-bound SpanLogger classes.
+ *
+ * Production workerd forbids code generation from strings (EvalError), so the
+ * compiled renderer in spanLoggerGenerator.ts cannot run there. This module
+ * assembles the SAME class shape from per-field closures instead of source
+ * text, mirroring arrow-builder's closureMaterializers.ts:
+ * - one shared prototype per schema/config plan,
+ * - methods installed with { value, writable: true, configurable: true, enumerable: false },
+ * - accessors installed with { get, configurable: true, enumerable: false },
+ * - constructors assign instance properties in the same order (V8 hidden classes).
+ *
+ * Every closure body mirrors the compiled class member it replaces, including
+ * evaluation order (append -> message write -> fields), guard conditions, and
+ * thrown error messages that callers observe.
+ */
+import type { SchemaType } from '@smoothbricks/arrow-builder';
+import type { SchemaEnumLookupDescriptor } from '../enumMetadata.js';
+import type { MessageLayoutFamily, MessagePhysicalLayout } from '../runtimeHint.js';
+import type { VocabularyGeneration } from '../vocabularyRegistry.js';
+/** Structural type of SPAN_LOGGER_HELPERS (kept local to avoid an import cycle). */
+export interface SpanLoggerRuntimeHelpers {
+    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;
+}
+/**
+ * How a schema column's storage is allocated and guarded (mirrors
+ * arrow-builder's ColumnAccessMode for the state-bound writer surface):
+ * - eager: allocated in the buffer constructor, no null bitmap
+ * - preallocated: allocated in the buffer constructor WITH a null bitmap
+ * - lazy: allocated on first public-getter access
+ */
+export type SpanLoggerColumnMode = 'eager' | 'preallocated' | 'lazy';
+/** One schema column of the SpanLogger plan. */
+export interface SpanLoggerColumnPlan {
+    readonly name: string;
+    readonly schemaType: SchemaType | undefined;
+    readonly mode: SpanLoggerColumnMode;
+}
+/**
+ * Pure-data description of one generated SpanLogger class, shared by the
+ * compiled renderer and this closure materializer. `helpers`/`enumLookup` are
+ * the same stable singletons the compiled path injects via `new Function`
+ * parameters (extension.dependencies).
+ */
+export interface SpanLoggerPlan {
+    readonly columns: readonly SpanLoggerColumnPlan[];
+    readonly messageLayoutFamily: MessageLayoutFamily;
+    readonly messagePhysicalLayout: MessagePhysicalLayout;
+    readonly helpers: SpanLoggerRuntimeHelpers;
+    readonly enumLookup: SchemaEnumLookupDescriptor;
+}
+/**
+ * Materialize a state-bound SpanLogger class from a plan without string
+ * codegen. Same observable behavior as the compiled renderer. Returned as
+ * `unknown` to flow through the same constructor type guard as the compiled
+ * factory (isSpanLoggerConstructor).
+ */
+export declare function materializeSpanLoggerClass(plan: SpanLoggerPlan): unknown;
+//# sourceMappingURL=spanLoggerClosureMaterializer.d.ts.map

package/dist/lib/codegen/spanLoggerClosureMaterializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanLoggerClosureMaterializer.d.ts","sourceRoot":"","sources":["../../../src/lib/codegen/spanLoggerClosureMaterializer.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAUpF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAMrE,oFAAoF;AACpF,MAAM,WAAW,wBAAwB;IACvC,4BAA4B,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3D,UAAU,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,uBAAuB,EAAE,CAAC,UAAU,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1F,mBAAmB,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACpF,sBAAsB,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACxG;AAED;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,cAAc,GAAG,MAAM,CAAC;AAErE,gDAAgD;AAChD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;CACrC;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAClD,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;IAClD,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB,CAAC;IACtD,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,0BAA0B,CAAC;CACjD;AA4LD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAiPxE"}