@smoothbricks/lmao 0.2.2 → 0.2.3

package/dist/lib/codegen/spanLoggerGenerator.js

@@ -15,9 +15,12 @@
  *
  * SpanLogger starts with _writeIndex = 1, so first _nextRow() makes it 2.
  */
-import { getColumnWriterClass, } from '@smoothbricks/arrow-builder';
+import { activeMaterializerMode, generateColumnWriterClass, } from '@smoothbricks/arrow-builder';
+import { resolveEnumLookupDescriptor, } from '../enumMetadata.js';
+import { decodeVocabularyMessage } from '../resolveMessage.js';
 import { ENTRY_TYPE_DEBUG, ENTRY_TYPE_ERROR, ENTRY_TYPE_FF_ACCESS, ENTRY_TYPE_FF_USAGE, ENTRY_TYPE_INFO, ENTRY_TYPE_TRACE, ENTRY_TYPE_WARN, } from '../schema/systemSchema.js';
-import { getEnumValues, getSchemaType } from '../schema/typeGuards.js';
+import { getSchemaType } from '../schema/typeGuards.js';
+import { materializeSpanLoggerClass, } from './spanLoggerClosureMaterializer.js';
 // =============================================================================
 // SINGLETON HELPERS OBJECT
 // =============================================================================
@@ -28,6 +31,12 @@ import { getEnumValues, getSchemaType } from '../schema/typeGuards.js';
  * Singleton - same object shared by all generated SpanLogger classes.
  */
 export const SPAN_LOGGER_HELPERS = {
+    normalizeOperationalTemplate: (template) => {
+        if (template.indexOf('{{') === -1 && template.indexOf('}}') === -1)
+            return template;
+        return template.replaceAll('{{', '{').replaceAll('}}', '}');
+    },
+    decodeVocabularyMessage,
     setNullBit: (bitmap, idx) => {
         bitmap[idx >>> 3] |= 1 << (idx & 7);
     },
@@ -126,35 +135,19 @@ export const SPAN_LOGGER_HELPERS = {
         }
     },
 };
-/**
- * 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 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) {
+function generateEnumFluentSetters(enumFields, enumEncoderNames) {
     const setters = [];
-    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;
     }`);
@@ -199,7 +192,7 @@ function generateSetScopeMethod() {
  * pattern of temporarily switching this._buffer for prefill then switching back.
  * Called by _checkOverflow after getting overflow buffer.
  */
-function generatePrefillScopedAttributesMethod(schemaFields, enumFieldNames) {
+function generatePrefillScopedAttributesMethod(schemaFields, enumEncoderNames) {
     const columnFills = schemaFields.map(([fieldName, fieldSchema]) => {
         const columnName = fieldName;
         const lmaoType = getSchemaType(fieldSchema);
@@ -220,8 +213,9 @@ function generatePrefillScopedAttributesMethod(schemaFields, enumFieldNames) {
         }
         // 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()
         if (lmaoType === 'category' || lmaoType === 'text') {
@@ -261,25 +255,36 @@ function generatePrefillScopedAttributesMethod(schemaFields, enumFieldNames) {
 /**
  * Build the extension for SpanLogger that extends ColumnWriter
  */
-function buildSpanLoggerExtension(schema) {
+function buildSpanLoggerExtension(schema, messageLayoutFamily, messagePhysicalLayout, eagerColumns, enumLookup) {
     const schemaFields = schema._columns;
-    // Collect enum mappings
-    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);
-        }
-    }
+    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;`;
+    });
     // 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) => {
+        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: `
   const ENTRY_TYPE_INFO = ${ENTRY_TYPE_INFO};
@@ -289,106 +294,87 @@ function buildSpanLoggerExtension(schema) {
   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')}
+${enumEncoderBindings.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;
-`,
-        // 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);
+        methods: 
+        // 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;
     }
 
@@ -412,15 +398,8 @@ function buildSpanLoggerExtension(schema) {
             // 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;
@@ -428,23 +407,14 @@ function buildSpanLoggerExtension(schema) {
           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);
       }
@@ -527,6 +497,7 @@ function buildSpanLoggerExtension(schema) {
         // Use singleton helpers object (created once at module load)
         dependencies: {
             helpers: SPAN_LOGGER_HELPERS,
+            enumLookup,
         },
     };
 }
@@ -537,43 +508,78 @@ const spanLoggerClassCache = new WeakMap();
 function isSpanLoggerConstructor(value) {
     return typeof value === 'function';
 }
+function generateStateBoundSpanLoggerClass(schema, extension) {
+    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, messageLayoutFamily, messagePhysicalLayout, eagerColumns, enumLookup) {
+    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, messageLayoutFamily, messagePhysicalLayout, eagerColumns, enumLookup) {
+    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 = 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(schema) {
-    // Check cache first
-    let SpanLoggerClass = spanLoggerClassCache.get(schema);
+export function createSpanLoggerClass(schema, messageLayoutFamily = 'mixed', messagePhysicalLayout = 'current', eagerColumns = [], enumLookup = resolveEnumLookupDescriptor(schema)) {
+    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(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(SpanLoggerClass)) {
         throw new Error('Invalid cached SpanLogger constructor');
     }
     return SpanLoggerClass;
 }
-/**
- * Create a SpanLogger instance for the given buffer.
- *
- * @param schema - Tag attribute schema
- * @param buffer - SpanBuffer to write to
- */
-export function createSpanLogger(schema, buffer) {
-    const SpanLoggerClass = createSpanLoggerClass(schema);
-    return new SpanLoggerClass(buffer);
+/** Create a SpanLogger bound to an existing SpanContext writer state. */
+export function createSpanLogger(schema, state) {
+    return new (createSpanLoggerClass(schema))(state);
 }
 //#endregion smoo/lmao!n/codegen-spanlogger

package/dist/lib/convertToArrow.d.ts

@@ -9,6 +9,7 @@
  */
 import { Column, type Table } from '@uwdata/flechette';
 import { type CapacityStatsEntry } from './arrow/capacityStats.js';
+import { type ArrowLease } from './arrow/lease.js';
 import type { LogSchema } from './schema/types.js';
 import type { AnySpanBuffer } from './types.js';
 type BuiltMetadataColumns = {
@@ -23,11 +24,13 @@ export type SystemColumnBuilder = (buffer: AnySpanBuffer, buffers: AnySpanBuffer
  * Dictionaries are built from the data in this batch only and are not shared
  * with other batches, even when combined into a Table.
  */
-export declare function convertToTable(buffer: AnySpanBuffer, systemColumnBuilder?: SystemColumnBuilder): Table;
+export declare function convertToTable(buffer: AnySpanBuffer, systemColumnBuilder?: SystemColumnBuilder, borrowChunks?: boolean): Table;
 /**
  * Convert SpanBuffer (and its overflow chain) to Arrow Table
  */
 export declare function convertToArrowTable<_T extends LogSchema = LogSchema>(buffer: AnySpanBuffer, systemColumnBuilder?: SystemColumnBuilder): Table;
+/** Borrow JS physical Arrow chunks until the returned lease is released. */
+export declare function convertToLeasedArrowTable(buffer: AnySpanBuffer, systemColumnBuilder?: SystemColumnBuilder): ArrowLease;
 /**
  * Convert SpanBuffer tree to Arrow Table
  *
@@ -35,6 +38,8 @@ export declare function convertToArrowTable<_T extends LogSchema = LogSchema>(bu
  * - Pass 1: Walk tree, build dictionaries (collect unique strings, cache UTF-8)
  * - Pass 2: Walk tree, convert each buffer to a table using shared dictionaries
  */
-export declare function convertSpanTreeToArrowTable(rootBuffer: AnySpanBuffer, _systemColumnBuilder?: SystemColumnBuilder, modulesToLogStats?: CapacityStatsEntry[], periodStartNs?: bigint): Table;
+export declare function convertSpanTreeToArrowTable(rootBuffer: AnySpanBuffer, _systemColumnBuilder?: SystemColumnBuilder, modulesToLogStats?: CapacityStatsEntry[], periodStartNs?: bigint, borrowChunks?: boolean): Table;
+/** Convert a logical trace tree while pinning every borrowed physical chunk. */
+export declare function convertSpanTreeToLeasedArrowTable(rootBuffer: AnySpanBuffer, systemColumnBuilder?: SystemColumnBuilder, modulesToLogStats?: CapacityStatsEntry[], periodStartNs?: bigint): ArrowLease;
 export {};
 //# sourceMappingURL=convertToArrow.d.ts.map

package/dist/lib/convertToArrow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertToArrow.d.ts","sourceRoot":"","sources":["../../src/lib/convertToArrow.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,EAIL,MAAM,EAMN,KAAK,KAAK,EASX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,kBAAkB,EAA4B,MAAM,0BAA0B,CAAC;AAqB7F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,YAAY,CAAC;AAO5D,KAAK,oBAAoB,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,CAAA;CAAE,CAAC;AAE7E,MAAM,MAAM,mBAAmB,GAAG,CAChC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,aAAa,EAAE,EACxB,SAAS,EAAE,MAAM,KACd,oBAAoB,CAAC;AAqd1B;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,KAAK,CAUtG;AAwYD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,SAAS,SAAS,GAAG,SAAS,EAClE,MAAM,EAAE,aAAa,EACrB,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,KAAK,CAIP;AAMD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,aAAa,EACzB,oBAAoB,CAAC,EAAE,mBAAmB,EAC1C,iBAAiB,CAAC,EAAE,kBAAkB,EAAE,EACxC,aAAa,CAAC,EAAE,MAAM,GACrB,KAAK,CAgPP"}
+{"version":3,"file":"convertToArrow.d.ts","sourceRoot":"","sources":["../../src/lib/convertToArrow.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,OAAO,EAIL,MAAM,EAMN,KAAK,KAAK,EASX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,kBAAkB,EAA4B,MAAM,0BAA0B,CAAC;AAQ7F,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AAyBrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,YAAY,CAAC;AAQ5D,KAAK,oBAAoB,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,CAAA;CAAE,CAAC;AAI7E,MAAM,MAAM,mBAAmB,GAAG,CAChC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,aAAa,EAAE,EACxB,SAAS,EAAE,MAAM,KACd,oBAAoB,CAAC;AAyqB1B;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,mBAAmB,CAAC,EAAE,mBAAmB,EACzC,YAAY,UAAQ,GACnB,KAAK,CAQP;AAgbD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,SAAS,SAAS,GAAG,SAAS,EAClE,MAAM,EAAE,aAAa,EACrB,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,KAAK,CAIP;AAED,4EAA4E;AAC5E,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,aAAa,EACrB,mBAAmB,CAAC,EAAE,mBAAmB,GACxC,UAAU,CAWZ;AAMD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,aAAa,EACzB,oBAAoB,CAAC,EAAE,mBAAmB,EAC1C,iBAAiB,CAAC,EAAE,kBAAkB,EAAE,EACxC,aAAa,CAAC,EAAE,MAAM,EACtB,YAAY,UAAQ,GACnB,KAAK,CA4OP;AAED,gFAAgF;AAChF,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,aAAa,EACzB,mBAAmB,CAAC,EAAE,mBAAmB,EACzC,iBAAiB,CAAC,EAAE,kBAAkB,EAAE,EACxC,aAAa,CAAC,EAAE,MAAM,GACrB,UAAU,CAQZ"}