@smoothbricks/lmao 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"evaluatorGenerator.d.ts","sourceRoot":"","sources":["../../../src/lib/codegen/evaluatorGenerator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EACV,aAAa,EAEb,4BAA4B,EAC5B,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,GAAG,SAAS,SAAS;IAC3D,GAAG,CAAC,CAAC,SAAS,MAAM,4BAA4B,CAAC,GAAG,CAAC,GAAG,MAAM,EAC5D,IAAI,EAAE,CAAC,GACN,OAAO,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpC,UAAU,CAAC,GAAG,EAAE,oBAAoB,CAAC,GAAG,CAAC,GAAG,0BAA0B,CAAC,GAAG,CAAC,CAAC;IAC5E,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,0BAA0B,CAAC,GAAG,SAAS,SAAS,IAAI,sBAAsB,CAAC,GAAG,CAAC,GACzF,4BAA4B,CAAC,GAAG,CAAC,CAAC;AAEpC,KAAK,6BAA6B,CAAC,GAAG,SAAS,SAAS,IAAI,KAC1D,WAAW,EAAE,oBAAoB,CAAC,GAAG,CAAC,EACtC,SAAS,EAAE,aAAa,CAAC,GAAG,CAAC,KAC1B,0BAA0B,CAAC,GAAG,CAAC,CAAC;AAErC,KAAK,iBAAiB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,OAAO,KAAK,OAAO,CAAC;AA4E9G;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,iBAAiB,EAChE,MAAM,EAAE,CAAC,EACT,SAAS,SAAuB,GAC/B,MAAM,CA2BR;AAwHD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,SAAS,SAAS,EACxD,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,EACpB,iBAAiB,EAAE,iBAAiB,EACpC,oBAAoB,EAAE,MAAM,GAC3B,6BAA6B,CAAC,GAAG,CAAC,CA6BpC"}

package/dist/lib/codegen/evaluatorGenerator.js

@@ -0,0 +1,199 @@
+/**
+ * Worker-safe feature-flag evaluator generation.
+ *
+ * Getter descriptors still live on the prototype, but the class is assembled with
+ * normal closures and `Object.defineProperties()` instead of `new Function(...)`.
+ */
+import { isRecord } from '@smoothbricks/validation';
+/**
+ * Cache for generated evaluator classes by schema reference.
+ */
+const evaluatorClassCache = new WeakMap();
+function isGeneratedEvaluatorConstructor(value) {
+    return typeof value === 'function';
+}
+function isGeneratedEvaluatorInstance(value) {
+    return isRecord(value);
+}
+function isAnySpanBuffer(value) {
+    return isRecord(value) && '_writeIndex' in value && 'entry_type' in value;
+}
+function isInternalSpanLogger(value) {
+    return isRecord(value) && 'ffAccess' in value && 'ffUsage' in value;
+}
+function getEvaluatorRuntimeContext(ctx) {
+    if (!isRecord(ctx) || !('_buffer' in ctx) || !('log' in ctx)) {
+        throw new Error('Feature-flag evaluator requires an internal span context');
+    }
+    if (!isAnySpanBuffer(ctx._buffer) || !isInternalSpanLogger(ctx.log)) {
+        throw new Error('Feature-flag evaluator requires runtime span buffer and logger internals');
+    }
+    return {
+        ...ctx,
+        _buffer: ctx._buffer,
+        log: ctx.log,
+    };
+}
+function createFlagGetter(flagName) {
+    return function generatedFlagGetter() {
+        return this.getFlag(flagName);
+    };
+}
+function buildGetterDescriptor(flagName) {
+    return {
+        configurable: true,
+        enumerable: false,
+        get: createFlagGetter(flagName),
+    };
+}
+function buildGetterDescriptors(flagNames) {
+    const descriptors = {};
+    for (const flagName of flagNames) {
+        descriptors[flagName] = buildGetterDescriptor(flagName);
+    }
+    return descriptors;
+}
+/**
+ * Render a debug view of the worker-safe generated class.
+ *
+ * This exists for snapshots/tests only; runtime assembly happens without eval.
+ */
+export function generateEvaluatorClass(schema, className = 'GeneratedEvaluator') {
+    const flagNames = Object.keys(schema);
+    const getterEntries = flagNames
+        .map((flagName) => `  ${flagName}: {
+    configurable: true,
+    enumerable: false,
+    get() {
+      return this.getFlag('${flagName}');
+    },
+  }`)
+        .join(',\n');
+    return `class ${className} extends WorkerSafeGeneratedEvaluator {
+  constructor(spanContext, evaluator) {
+    super(spanContext, evaluator, SCHEMA, validateFlagValue, ENTRY_TYPE_FF_ACCESS);
+  }
+
+  forContext(ctx) {
+    return new ${className}(ctx, this.evaluator);
+  }
+}
+
+Object.defineProperties(${className}.prototype, {
+${getterEntries}
+});`;
+}
+class WorkerSafeGeneratedEvaluator {
+    #spanContext;
+    #evaluator;
+    #schema;
+    #validateFlagValue;
+    #entryTypeFfAccess;
+    constructor(spanContext, evaluator, schema, validateFlagValue, entryTypeFfAccess) {
+        this.#spanContext = getEvaluatorRuntimeContext(spanContext);
+        this.#evaluator = evaluator;
+        this.#schema = schema;
+        this.#validateFlagValue = validateFlagValue;
+        this.#entryTypeFfAccess = entryTypeFfAccess;
+    }
+    get evaluator() {
+        return this.#evaluator;
+    }
+    hasLoggedAccess(flagName) {
+        let buf = this.#spanContext._buffer;
+        while (buf) {
+            const limit = buf._writeIndex;
+            for (let i = limit - 1; i >= 0; i--) {
+                if (buf.entry_type[i] === this.#entryTypeFfAccess && buf.message_values && buf.message_values[i] === flagName) {
+                    return true;
+                }
+            }
+            buf = buf._overflow;
+        }
+        return false;
+    }
+    getFlag(flagName) {
+        const ctx = this.#spanContext;
+        const definition = this.getDefinition(flagName);
+        const rawValue = this.#evaluator.getSync(ctx, flagName);
+        const value = this.#validateFlagValue(rawValue, definition.schema, definition.defaultValue);
+        if (!this.hasLoggedAccess(flagName)) {
+            this.getLogger().ffAccess(flagName, rawValue);
+        }
+        if (!value) {
+            return undefined;
+        }
+        return this.wrapValue(flagName, value);
+    }
+    async get(flag) {
+        const ctx = this.#spanContext;
+        const definition = this.getDefinition(flag);
+        const rawValue = await this.#evaluator.getAsync(ctx, flag);
+        const value = this.#validateFlagValue(rawValue, definition.schema, definition.defaultValue);
+        if (!this.hasLoggedAccess(flag)) {
+            this.getLogger().ffAccess(flag, rawValue);
+        }
+        if (!value) {
+            return undefined;
+        }
+        return this.wrapValue(flag, value);
+    }
+    forContext(_ctx) {
+        throw new Error('forContext() must be implemented by the schema-specific evaluator class');
+    }
+    getDefinition(flagName) {
+        const definition = this.#schema[flagName];
+        if (!definition) {
+            throw new Error(`Unknown feature flag: ${flagName}`);
+        }
+        return definition;
+    }
+    wrapValue(flagName, value) {
+        const track = (context) => this.logUsage(flagName, context);
+        if (typeof value === 'boolean') {
+            return { value: true, track };
+        }
+        if (typeof value === 'string') {
+            return { value, track };
+        }
+        if (typeof value === 'object' && value !== null) {
+            return { ...value, track };
+        }
+        return { value, track };
+    }
+    getLogger() {
+        return this.#spanContext.log;
+    }
+    logUsage(flagName, context) {
+        return this.getLogger().ffUsage(flagName, context ? { ...context } : undefined);
+    }
+}
+/**
+ * Create evaluator class constructor from schema.
+ * This is the cold-path function called at schema definition time.
+ */
+export function createEvaluatorClass(schema, validateFlagValue, ENTRY_TYPE_FF_ACCESS) {
+    const cached = evaluatorClassCache.get(schema);
+    if (isGeneratedEvaluatorConstructor(cached)) {
+        return cached;
+    }
+    class GeneratedEvaluator extends WorkerSafeGeneratedEvaluator {
+        constructor(spanContext, evaluator) {
+            super(spanContext, evaluator, schema, validateFlagValue, ENTRY_TYPE_FF_ACCESS);
+        }
+        forContext(ctx) {
+            const nextEvaluator = new GeneratedEvaluator(ctx, this.evaluator);
+            if (!isGeneratedEvaluatorInstance(nextEvaluator)) {
+                throw new Error('Failed to create feature-flag evaluator instance');
+            }
+            return nextEvaluator;
+        }
+    }
+    Object.defineProperties(GeneratedEvaluator.prototype, buildGetterDescriptors(Object.keys(schema)));
+    const generatedEvaluatorClass = GeneratedEvaluator;
+    evaluatorClassCache.set(schema, generatedEvaluatorClass);
+    if (!isGeneratedEvaluatorConstructor(generatedEvaluatorClass)) {
+        throw new Error('Failed to generate feature-flag evaluator constructor');
+    }
+    return generatedEvaluatorClass;
+}

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

@@ -0,0 +1,139 @@
+/**
+ * Runtime code generation for TagWriter and ResultWriter classes
+ *
+ * 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
+ */
+import type { InferSchema, LogSchema } from '../schema/types.js';
+import type { AnySpanBuffer } from '../types.js';
+/**
+ * Extension options for injecting custom code into generated writer classes.
+ */
+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;
+}
+/**
+ * TagWriter interface - fluent setter API for span-start attributes (row 0)
+ */
+export type TagWriter<T extends LogSchema> = {
+    /**
+     * Bulk set multiple attributes at once.
+     */
+    with(attributes: Partial<InferSchema<T>>): TagWriter<T>;
+} & {
+    [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;
+    /**
+     * Bulk set multiple attributes at once.
+     */
+    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>;
+} & {
+    [K in keyof InferSchema<T>]: (value: InferSchema<T>[K]) => ResultWriter<T, R, E>;
+};
+/**
+ * Generate the complete fixed-position writer class code.
+ *
+ * @param schema - Tag attribute schema defining columns
+ * @param position - Fixed position to write to (0 for TagWriter, 1 for ResultWriter)
+ * @param className - Name for the generated class
+ * @param extension - Optional extension for constructor code, methods, params
+ * @returns JavaScript code string for the class
+ */
+export declare function generateFixedPositionWriterClass(schema: LogSchema, position: number, className: string, extension?: FixedPositionWriterExtension): string;
+/**
+ * Generate TagWriter class code for a schema.
+ * TagWriter writes to position 0 (span-start row).
+ */
+export declare function generateTagWriterClass(schema: LogSchema): string;
+/**
+ * Get or create a cached TagWriter class for a schema.
+ *
+ * @param schema - Tag attribute schema
+ * @returns TagWriter class constructor
+ */
+export declare function getTagWriterClass<T extends LogSchema>(schema: T): new (buffer: AnySpanBuffer) => TagWriter<T>;
+/**
+ * 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 declare function createTagWriter<T extends LogSchema>(schema: T, buffer: AnySpanBuffer): TagWriter<T>;
+/**
+ * Generate ResultWriter class code for a schema.
+ * ResultWriter writes to position 1 (result row).
+ */
+export declare function generateResultWriterClass(schema: LogSchema): string;
+/**
+ * Get or create a cached ResultWriter class for a schema.
+ *
+ * @param schema - Tag attribute schema
+ * @returns ResultWriter class constructor
+ */
+export declare function getResultWriterClass<T extends LogSchema>(schema: T): new <R = unknown, E = unknown>(buffer: AnySpanBuffer, resultOrError: unknown, isError: boolean) => ResultWriter<T, R, E>;
+/**
+ * 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 declare function createResultWriter<T extends LogSchema, R = unknown, E = unknown>(schema: T, buffer: AnySpanBuffer, resultOrError: R | E, isError: boolean): ResultWriter<T, R, E>;
+//# sourceMappingURL=fixedPositionWriterGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fixedPositionWriterGenerator.d.ts","sourceRoot":"","sources":["../../../src/lib/codegen/fixedPositionWriterGenerator.ts"],"names":[],"mappings":"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"}

package/dist/lib/codegen/fixedPositionWriterGenerator.js

@@ -0,0 +1,289 @@
+/**
+ * Runtime code generation for TagWriter and ResultWriter classes
+ *
+ * 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
+ */
+import { bufferHelpers } from '@smoothbricks/arrow-builder';
+import { getEnumValues, getSchemaType } from '../schema/typeGuards.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
+    return `
+    ${fieldName}(value) {
+      this._buffer.${columnName}(this._pos, value);
+      return this;
+    }`;
+}
+/**
+ * Generate with() method code - bulk attribute setting.
+ * UNROLLED per-column code for zero Object.entries overhead.
+ */
+function generateWithMethod(schemaFields, enumFieldNames) {
+    const columnWrites = schemaFields.map(([fieldName]) => {
+        const hasEnumMapping = enumFieldNames.has(fieldName);
+        const valueExpr = hasEnumMapping ? `getEnumIndex_${fieldName}(attributes.${fieldName})` : `attributes.${fieldName}`;
+        return `
+      if ('${fieldName}' in attributes && attributes.${fieldName} !== null && attributes.${fieldName} !== undefined) {
+        this._buffer.${fieldName}(this._pos, ${valueExpr});
+      }`;
+    });
+    return `
+    with(attributes) {
+      ${columnWrites.join('\n')}
+      return this;
+    }`;
+}
+/**
+ * Generate the complete fixed-position writer class code.
+ *
+ * @param schema - Tag attribute schema defining columns
+ * @param position - Fixed position to write to (0 for TagWriter, 1 for ResultWriter)
+ * @param className - Name for the generated class
+ * @param extension - Optional extension for constructor code, methods, params
+ * @returns JavaScript code string for the class
+ */
+export function generateFixedPositionWriterClass(schema, position, className, extension) {
+    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);
+    }
+    // Build extension methods (additional methods injected by the caller)
+    const extensionMethods = extension?.methods
+        ? '\n' +
+            extension.methods
+                .trim()
+                .split('\n')
+                .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)
+    const classCode = `
+  'use strict';
+
+  ${enumMappings.join('\n')}
+
+  class ${className} {
+    constructor(${constructorSignature}) {
+${constructorBody.join('\n')}
+    }
+
+    ${withMethod}
+
+    ${setterMethods.join('\n')}
+${extensionMethods}
+  }
+
+  return ${className};
+`;
+    return classCode;
+}
+// ============================================================================
+// Class Caches
+// ============================================================================
+/**
+ * Cache for TagWriter classes (position 0).
+ * WeakMap allows garbage collection when schema is no longer referenced.
+ */
+const tagWriterClassCache = new WeakMap();
+/**
+ * Cache for ResultWriter classes (position 1).
+ */
+const resultWriterClassCache = new WeakMap();
+// ============================================================================
+// TagWriter API
+// ============================================================================
+/**
+ * Generate TagWriter class code for a schema.
+ * TagWriter writes to position 0 (span-start row).
+ */
+export function generateTagWriterClass(schema) {
+    return generateFixedPositionWriterClass(schema, 0, 'GeneratedTagWriter');
+}
+/**
+ * Get or create a cached TagWriter class for a schema.
+ *
+ * @param schema - Tag attribute schema
+ * @returns TagWriter class constructor
+ */
+export function getTagWriterClass(schema) {
+    let WriterClass = tagWriterClassCache.get(schema);
+    if (!WriterClass) {
+        const classCode = generateTagWriterClass(schema).trim();
+        // Compile with new Function()
+        const factory = new Function('helpers', classCode);
+        WriterClass = factory(bufferHelpers);
+        if (!isTagWriterConstructor(WriterClass)) {
+            throw new Error('Failed to generate TagWriter constructor');
+        }
+        tagWriterClassCache.set(schema, WriterClass);
+    }
+    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);
+}
+// ============================================================================
+// 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: `
+message(text) {
+  this._buffer.message(this._pos, text);
+  return this;
+}
+
+line(lineNumber) {
+  this._buffer.line(this._pos, lineNumber);
+  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);
+}
+/**
+ * Get or create a cached ResultWriter class for a schema.
+ *
+ * @param schema - Tag attribute schema
+ * @returns ResultWriter class constructor
+ */
+export function getResultWriterClass(schema) {
+    let WriterClass = resultWriterClassCache.get(schema);
+    if (!WriterClass) {
+        const classCode = generateResultWriterClass(schema).trim();
+        // Compile with new Function()
+        const factory = new Function('helpers', classCode);
+        WriterClass = factory(bufferHelpers);
+        if (!isResultWriterConstructor(WriterClass)) {
+            throw new Error('Failed to generate ResultWriter constructor');
+        }
+        resultWriterClassCache.set(schema, 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
+ */
+export function createResultWriter(schema, buffer, resultOrError, isError) {
+    const WriterClass = getResultWriterClass(schema);
+    return new WriterClass(buffer, resultOrError, isError);
+}