@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/codegen/__tests__/evaluatorGenerator.test.ts

@@ -1,27 +1,17 @@
 import { describe, expect, test } from 'bun:test';
-import { createBuffer, createTestLogBinding, createTestSchema } from '../../__tests__/test-helpers.js';
+import { createBuffer, createTestSchema, createTestSpanContext } from '../../__tests__/test-helpers.js';
 import type { OpContext } from '../../opContext/types.js';
+import { resolveEntryType } from '../../resolveMessage.js';
 import { S } from '../../schema/builder.js';
 import type { FeatureFlagSchema } from '../../schema/defineFeatureFlags.js';
 import { defineFeatureFlags } from '../../schema/defineFeatureFlags.js';
 import { InMemoryFlagEvaluator } from '../../schema/evaluator.js';
 import { ENTRY_TYPE_FF_ACCESS, ENTRY_TYPE_FF_USAGE } from '../../schema/systemSchema.js';
-import type { LogSchema } from '../../schema/types.js';
-import { createSpanContextClass, type SpanContextInstance } from '../../spanContext.js';
+import type { LogSchema, SchemaFields } from '../../schema/types.js';
 import type { AnySpanBuffer, SpanBuffer } from '../../types.js';
 import { createEvaluatorClass, generateEvaluatorClass } from '../evaluatorGenerator.js';
-import { createTagWriter } from '../fixedPositionWriterGenerator.js';
-import { createSpanLogger } from '../spanLoggerGenerator.js';
 
-/**
- * Create a mock SpanContext for testing FeatureFlagEvaluator
- *
- * The evaluator needs:
- * - _buffer with scopeValues and writeIndex
- * - log with ffAccess, ffUsage, and _writeIndex
- * - buffer getter that returns _buffer
- *
- */
+/** Create a real shared SpanContext for testing FeatureFlagEvaluator. */
 type EvaluatorTestContext<TLogSchema extends LogSchema, TFlags extends FeatureFlagSchema> = OpContext<
   TLogSchema,
   TFlags,
@@ -29,96 +19,16 @@ type EvaluatorTestContext<TLogSchema extends LogSchema, TFlags extends FeatureFl
   Record<string, never>
 >;
 
-function createMockSpanContext<TLogSchema extends LogSchema, TFlags extends FeatureFlagSchema>(
-  schema: TLogSchema,
-  spanBuffer: SpanBuffer<TLogSchema>,
-): SpanContextInstance<EvaluatorTestContext<TLogSchema, TFlags>> {
-  const logger = createSpanLogger(schema, spanBuffer);
-  const tagWriter = createTagWriter(schema, spanBuffer);
-  const SpanContextClass = createSpanContextClass<EvaluatorTestContext<TLogSchema, TFlags>>(
-    schema,
-    createTestLogBinding(schema),
-  );
-  const ctx = new SpanContextClass(spanBuffer, schema, logger, tagWriter);
-  ctx.deps = {};
-  return ctx;
+function createMockSpanContext<TFields extends SchemaFields, const TFlags extends FeatureFlagSchema>(
+  schema: LogSchema<TFields>,
+  spanBuffer: SpanBuffer<LogSchema<TFields>>,
+  _flags: TFlags,
+) {
+  return createTestSpanContext<TFields, EvaluatorTestContext<LogSchema<TFields>, TFlags>>(schema, spanBuffer);
 }
 
 describe('EvaluatorGenerator', () => {
-  describe('generateEvaluatorClass', () => {
-    test('generates valid JavaScript class code', () => {
-      const schema = defineFeatureFlags({
-        debugMode: S.boolean().default(false).sync(),
-        maxRetries: S.number().default(3).sync(),
-      });
-
-      const code = generateEvaluatorClass(schema.schema);
-
-      expect(code).toContain('class GeneratedEvaluator extends WorkerSafeGeneratedEvaluator');
-      expect(code).toContain('Object.defineProperties(GeneratedEvaluator.prototype');
-
-      // Should describe the generated getters for each flag
-      expect(code).toContain("return this.getFlag('debugMode')");
-      expect(code).toContain("return this.getFlag('maxRetries')");
-
-      // Should have new API methods (not old ones)
-      expect(code).toContain('forContext(ctx)');
-      expect(code).toContain('super(spanContext, evaluator, SCHEMA, validateFlagValue, ENTRY_TYPE_FF_ACCESS);');
-
-      // Should NOT have old API methods
-      expect(code).not.toContain('withBuffer(');
-      expect(code).not.toContain('getContext()');
-      expect(code).not.toContain('new Function');
-    });
-
-    test('generates unique getter for each flag', () => {
-      const schema = defineFeatureFlags({
-        featureA: S.boolean().default(false).sync(),
-        featureB: S.boolean().default(false).sync(),
-        featureC: S.number().default(0).sync(),
-        featureD: S.enum(['a', 'b', 'c'] as const)
-          .default('a')
-          .sync(),
-      });
-
-      const code = generateEvaluatorClass(schema.schema);
-
-      expect(code).toContain('featureA: {');
-      expect(code).toContain('featureB: {');
-      expect(code).toContain('featureC: {');
-      expect(code).toContain('featureD: {');
-
-      // Each getter should call getFlag with the flag name
-      expect(code).toContain("this.getFlag('featureA')");
-      expect(code).toContain("this.getFlag('featureB')");
-      expect(code).toContain("this.getFlag('featureC')");
-      expect(code).toContain("this.getFlag('featureD')");
-    });
-  });
-
   describe('createEvaluatorClass', () => {
-    test('creates a functional class constructor', () => {
-      const ffSchema = defineFeatureFlags({
-        debugMode: S.boolean().default(false).sync(),
-      });
-      const logSchema = createTestSchema({});
-      const spanBuffer = createBuffer(logSchema);
-      type Ctx = EvaluatorTestContext<typeof logSchema, typeof ffSchema.schema>;
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
-
-      const GeneratedClass = createEvaluatorClass<Ctx>(
-        ffSchema.schema,
-        (value, _schema, def) => value ?? def,
-        ENTRY_TYPE_FF_ACCESS,
-      );
-
-      expect(typeof GeneratedClass).toBe('function');
-
-      const evaluator = new InMemoryFlagEvaluator<Ctx>(ffSchema.schema, { debugMode: true });
-      const instance = new GeneratedClass(mockCtx, evaluator);
-      expect(instance).toBeDefined();
-    });
-
     test('caches generated classes by schema', () => {
       const schema = defineFeatureFlags({
         testFlag: S.boolean().default(false).sync(),
@@ -158,7 +68,7 @@ describe('EvaluatorGenerator', () => {
       const logSchema = createTestSchema({});
       const spanBuffer = createBuffer(logSchema);
       type Ctx = EvaluatorTestContext<typeof logSchema, typeof ffSchema.schema>;
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
+      const mockCtx = createMockSpanContext(logSchema, spanBuffer, ffSchema.schema);
 
       const GeneratedClass = createEvaluatorClass<Ctx>(
         ffSchema.schema,
@@ -184,7 +94,7 @@ describe('EvaluatorGenerator', () => {
       const logSchema = createTestSchema({});
       const spanBuffer = createBuffer(logSchema);
       type Ctx = EvaluatorTestContext<typeof logSchema, typeof ffSchema.schema>;
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
+      const mockCtx = createMockSpanContext(logSchema, spanBuffer, ffSchema.schema);
 
       const GeneratedClass = createEvaluatorClass<Ctx>(
         ffSchema.schema,
@@ -206,7 +116,7 @@ describe('EvaluatorGenerator', () => {
       const logSchema = createTestSchema({});
       const spanBuffer = createBuffer(logSchema);
       type Ctx = EvaluatorTestContext<typeof logSchema, typeof ffSchema.schema>;
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
+      const mockCtx = createMockSpanContext(logSchema, spanBuffer, ffSchema.schema);
 
       const GeneratedClass = createEvaluatorClass<Ctx>(
         ffSchema.schema,
@@ -219,7 +129,7 @@ describe('EvaluatorGenerator', () => {
 
       // Create a new SpanContext for child span
       const childBuffer = createBuffer(logSchema);
-      const childCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, childBuffer);
+      const childCtx = createMockSpanContext(logSchema, childBuffer, ffSchema.schema);
 
       const childInstance = instance.forContext(childCtx);
 
@@ -229,14 +139,11 @@ describe('EvaluatorGenerator', () => {
     });
 
     test('span context scope getter returns the typed buffer scope contract', () => {
-      const ffSchema = defineFeatureFlags({
-        debugMode: S.boolean().default(false).sync(),
-      });
       const logSchema = createTestSchema({
         requestId: S.category(),
       });
       const spanBuffer = createBuffer(logSchema);
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
+      const mockCtx = createTestSpanContext(logSchema, spanBuffer);
 
       spanBuffer._scopeValues = Object.freeze({ requestId: 'req-123' });
 
@@ -258,7 +165,7 @@ describe('EvaluatorGenerator', () => {
       const logSchema = createTestSchema({});
       const spanBuffer = createBuffer(logSchema);
       type Ctx = EvaluatorTestContext<typeof logSchema, typeof ffSchema.schema>;
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
+      const mockCtx = createMockSpanContext(logSchema, spanBuffer, ffSchema.schema);
 
       let evalCount = 0;
       const trackingEvaluator = new InMemoryFlagEvaluator<Ctx>(ffSchema.schema, { debugMode: true });
@@ -296,7 +203,7 @@ describe('EvaluatorGenerator', () => {
       const logSchema = createTestSchema({});
       const spanBuffer = createBuffer(logSchema);
       type Ctx = EvaluatorTestContext<typeof logSchema, typeof ffSchema.schema>;
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
+      const mockCtx = createMockSpanContext(logSchema, spanBuffer, ffSchema.schema);
 
       const GeneratedClass = createEvaluatorClass<Ctx>(
         ffSchema.schema,
@@ -325,7 +232,7 @@ describe('EvaluatorGenerator', () => {
       });
       const spanBuffer = createBuffer(logSchema);
       type Ctx = EvaluatorTestContext<typeof logSchema, typeof ffSchema.schema>;
-      const mockCtx = createMockSpanContext<typeof logSchema, typeof ffSchema.schema>(logSchema, spanBuffer);
+      const mockCtx = createMockSpanContext(logSchema, spanBuffer, ffSchema.schema);
 
       const GeneratedClass = createEvaluatorClass<Ctx>(
         ffSchema.schema,
@@ -346,7 +253,7 @@ describe('EvaluatorGenerator', () => {
       // Context should be applied via with(context)
       let usageIdx = -1;
       for (let i = 0; i < spanBuffer._writeIndex; i++) {
-        if (spanBuffer.entry_type[i] === ENTRY_TYPE_FF_USAGE) {
+        if (resolveEntryType(spanBuffer, i) === ENTRY_TYPE_FF_USAGE) {
           usageIdx = i;
           break;
         }
@@ -376,7 +283,7 @@ describe('EvaluatorGenerator', () => {
 
       const createInstance = () => {
         const spanBuffer = createBuffer(logSchema);
-        const mockCtx = createMockSpanContext<typeof logSchema, typeof schema.schema>(logSchema, spanBuffer);
+        const mockCtx = createMockSpanContext(logSchema, spanBuffer, schema.schema);
         return new GeneratedClass(mockCtx, mockEvaluator);
       };
 
@@ -414,33 +321,6 @@ describe('EvaluatorGenerator', () => {
       expect(descriptor?.enumerable).toBe(false);
       expect(descriptor?.configurable).toBe(true);
     });
-
-    test('no Proxy in generated class', () => {
-      const schema = defineFeatureFlags({
-        testFlag: S.boolean().default(false).sync(),
-      });
-
-      const code = generateEvaluatorClass(schema.schema);
-
-      // Generated code should not contain Proxy
-      expect(code).not.toContain('new Proxy');
-      expect(code).not.toContain('Proxy(');
-    });
-
-    test('runtime path stays worker-safe', () => {
-      const schema = defineFeatureFlags({
-        testFlag: S.boolean().default(false).sync(),
-      });
-
-      const GeneratedClass = createEvaluatorClass(
-        schema.schema,
-        (value, _schema, def) => value ?? def,
-        ENTRY_TYPE_FF_ACCESS,
-      );
-
-      expect(() => GeneratedClass).not.toThrow();
-      expect(GeneratedClass.toString()).not.toContain('new Function');
-    });
   });
 });
 
@@ -506,7 +386,7 @@ function countEntryType(buffer: AnySpanBuffer, entryType: number): number {
   while (current) {
     const writeIndex = current._writeIndex;
     for (let i = 0; i < writeIndex; i++) {
-      if (current.entry_type[i] === entryType) {
+      if (resolveEntryType(current, i) === entryType) {
         count++;
       }
     }

package/src/lib/codegen/__tests__/fixedPositionWriter-parity.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Compiled vs closure-composed fixed-position writer parity.
+ *
+ * getResultWriterClass selects between the compiled renderer (new Function)
+ * and the closure-composed materializer via activeMaterializerMode(). This
+ * suite drives identical write scripts through both classes against real
+ * SpanBuffers and byte-compares every touched lane (values, null bitmaps,
+ * message lanes). TagWriter ships closure-only, so its closure class is
+ * compared against a compiled reference built from the still-exported
+ * generateFixedPositionWriterClass source.
+ *
+ * Both materializers run under bun via the explicit override hook
+ * (setMaterializerModeOverride); afterEach restores probe-based selection.
+ */
+
+import { afterEach, describe, expect, it } from 'bun:test';
+import { activeMaterializerMode, bufferHelpers, setMaterializerModeOverride } from '@smoothbricks/arrow-builder';
+import {
+  createTestOpMetadata,
+  createTestSchema,
+  createTestSpanContext,
+  createTestTraceRoot,
+} from '../../__tests__/test-helpers.js';
+import { resolveEnumLookupDescriptor } from '../../enumMetadata.js';
+import type { MessageLayoutFamily } from '../../runtimeHint.js';
+import { S } from '../../schema/builder.js';
+import type { LogSchema, SchemaFields } from '../../schema/types.js';
+import { createSpanBuffer, getSpanBufferClass } from '../../spanBuffer.js';
+import type { AnySpanBuffer } from '../../types.js';
+import {
+  generateFixedPositionWriterClass,
+  getResultWriterClass,
+  getTagWriterClass,
+  type WriterState,
+} from '../fixedPositionWriterGenerator.js';
+
+afterEach(() => {
+  setMaterializerModeOverride(undefined);
+});
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+// >256 values force the Uint16 enum index lane, the widest special case.
+const wideEnumValues = Array.from({ length: 300 }, (_, i) => `value_${i}`);
+
+// Every value family the writer generator can route to a SpanBuffer setter.
+function createParityFields() {
+  return {
+    status: S.enum(['ok', 'err']),
+    wide: S.enum(wideEnumValues),
+    cat: S.category(),
+    txt: S.text(),
+    num: S.number(),
+    bool: S.boolean(),
+    bin: S.binary(),
+    obj: S.object<{ a: number }>(),
+  };
+}
+
+const USER_LANES = ['status', 'wide', 'cat', 'txt', 'num', 'bool', 'bin', 'obj'] as const;
+const SYSTEM_LANES = ['uint64_value', 'line'] as const;
+
+// SpanBuffer classes still require string codegen, so buffers and contexts are
+// created under the default (compiled) mode; only writer-class creation runs
+// under the closure override.
+function createBufferPair<T extends SchemaFields>(schema: LogSchema<T>, family: MessageLayoutFamily) {
+  const BufferClass = getSpanBufferClass(schema, family);
+  const bufferA = createSpanBuffer(schema, createTestTraceRoot('a'), createTestOpMetadata(), 8, BufferClass);
+  const bufferB = createSpanBuffer(schema, createTestTraceRoot('b'), createTestOpMetadata(), 8, BufferClass);
+  return {
+    bufferA,
+    bufferB,
+    contextA: createTestSpanContext(schema, bufferA),
+    contextB: createTestSpanContext(schema, bufferB),
+  };
+}
+
+function withClosureMode<T>(create: () => T): T {
+  setMaterializerModeOverride('closure');
+  try {
+    return create();
+  } finally {
+    setMaterializerModeOverride(undefined);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Reflect helpers (schema-dynamic methods; repo lint bans unsafe assertions)
+// ---------------------------------------------------------------------------
+
+function constructWriter(ctor: unknown, state: WriterState): object {
+  if (typeof ctor !== 'function') throw new Error('writer constructor is not callable');
+  const instance: unknown = Reflect.construct(ctor, [state]);
+  if (typeof instance !== 'object' || instance === null) throw new Error('writer construction failed');
+  return instance;
+}
+
+function call(writer: object, method: string, value: unknown): unknown {
+  const fn = Reflect.get(writer, method);
+  if (typeof fn !== 'function') throw new Error(`missing writer method ${JSON.stringify(method)}`);
+  return Reflect.apply(fn, writer, [value]);
+}
+
+function prototypeOf(ctor: unknown): object {
+  if (typeof ctor !== 'function') throw new Error('expected a constructor');
+  const proto: unknown = Reflect.get(ctor, 'prototype');
+  if (typeof proto !== 'object' || proto === null) throw new Error('expected a prototype object');
+  return proto;
+}
+
+function nameOf(ctor: unknown): string {
+  if (typeof ctor !== 'function') throw new Error('expected a constructor');
+  return ctor.name;
+}
+
+// ---------------------------------------------------------------------------
+// Write scripts (identical for both materializers)
+// ---------------------------------------------------------------------------
+
+function runFieldScript(writer: object): void {
+  // Invalid enum values encode to ordinal 0 before the valid overwrite.
+  expect(call(writer, 'status', 'not-a-value')).toBe(writer);
+  call(writer, 'status', 'err');
+  call(writer, 'wide', 'value_299');
+  call(writer, 'cat', 'checkout');
+  call(writer, 'txt', 'unique text \u2713');
+  call(writer, 'num', 42.5);
+  call(writer, 'bool', true);
+  call(writer, 'bin', Uint8Array.of(1, 2, 3));
+  call(writer, 'obj', { a: 7 });
+  call(writer, 'uint64_value', 123456789n);
+  // Bulk set: null/undefined entries are skipped, unknown keys ignored.
+  call(writer, 'with', { status: 'ok', num: 7, cat: null, txt: undefined, notAColumn: 'ignored' });
+}
+
+function runResultScript(writer: object): void {
+  runFieldScript(writer);
+  call(writer, 'message', 'span message');
+  call(writer, 'line', 1234);
+}
+
+// ---------------------------------------------------------------------------
+// Lane comparison
+// ---------------------------------------------------------------------------
+
+function expectIdenticalLanes(actual: AnySpanBuffer, expected: AnySpanBuffer, lanes: readonly string[]): void {
+  for (const lane of lanes) {
+    const actualValues = actual.getColumnIfAllocated(lane);
+    const expectedValues = expected.getColumnIfAllocated(lane);
+    expect(actualValues?.constructor).toBe(expectedValues?.constructor);
+    expect(actualValues).toEqual(expectedValues);
+    expect(actual.getNullsIfAllocated(lane)).toEqual(expected.getNullsIfAllocated(lane));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// ResultWriter parity (compiled vs closure)
+// ---------------------------------------------------------------------------
+
+describe('ResultWriter compiled/closure parity', () => {
+  const families: readonly MessageLayoutFamily[] = ['mixed', 'dynamic-only', 'static-only'];
+
+  for (const family of families) {
+    it(`writes byte-identical lanes for the ${family} message layout family`, () => {
+      expect(activeMaterializerMode()).toBe('compiled');
+      const schema = createTestSchema(createParityFields());
+      const { bufferA, bufferB, contextA, contextB } = createBufferPair(schema, family);
+
+      const Compiled = getResultWriterClass(schema, family, 'current');
+      const Closure = withClosureMode(() => getResultWriterClass(schema, family, 'current'));
+      expect(Closure).not.toBe(Compiled);
+      expect(nameOf(Closure)).toBe(nameOf(Compiled));
+
+      const compiledWriter = constructWriter(Compiled, contextA);
+      const closureWriter = constructWriter(Closure, contextB);
+      expect(Reflect.ownKeys(closureWriter)).toEqual(Reflect.ownKeys(compiledWriter));
+
+      runResultScript(compiledWriter);
+      runResultScript(closureWriter);
+
+      expectIdenticalLanes(bufferB, bufferA, [...USER_LANES, ...SYSTEM_LANES]);
+      if (family === 'static-only') {
+        expect(bufferA._terminalMessage).toBe('span message');
+        expect(bufferB._terminalMessage).toBe(bufferA._terminalMessage);
+        expect(bufferB.message_values).toBeUndefined();
+        expect(bufferA.message_values).toBeUndefined();
+      } else {
+        expect(bufferA.message_values?.[1]).toBe('span message');
+        expect(bufferB.message_values).toEqual(bufferA.message_values);
+        expect(bufferB._terminalMessage).toBe(bufferA._terminalMessage);
+      }
+    });
+  }
+
+  it('installs class-member-equivalent prototype descriptors', () => {
+    const schema = createTestSchema(createParityFields());
+    const Compiled = getResultWriterClass(schema, 'mixed', 'current');
+    const Closure = withClosureMode(() => getResultWriterClass(schema, 'mixed', 'current'));
+
+    const compiledProto = prototypeOf(Compiled);
+    const closureProto = prototypeOf(Closure);
+    const members = [...schema._columns.map(([fieldName]) => fieldName), 'with', 'message', 'line', 'uint64_value'];
+
+    for (const member of members) {
+      const compiledDescriptor = Object.getOwnPropertyDescriptor(compiledProto, member);
+      const closureDescriptor = Object.getOwnPropertyDescriptor(closureProto, member);
+      if (!compiledDescriptor || !closureDescriptor) {
+        throw new Error(`missing prototype member ${JSON.stringify(member)}`);
+      }
+      expect(closureDescriptor.writable).toBe(compiledDescriptor.writable);
+      expect(closureDescriptor.configurable).toBe(compiledDescriptor.configurable);
+      expect(closureDescriptor.enumerable).toBe(compiledDescriptor.enumerable);
+      expect(typeof closureDescriptor.value).toBe(typeof compiledDescriptor.value);
+      if (typeof closureDescriptor.value === 'function' && typeof compiledDescriptor.value === 'function') {
+        expect(closureDescriptor.value.name).toBe(compiledDescriptor.value.name);
+      }
+    }
+  });
+
+  it('caches classes per materializer mode and restores on override reset', () => {
+    const schema = createTestSchema({ n: S.number() });
+    const compiled = getResultWriterClass(schema);
+    expect(getResultWriterClass(schema)).toBe(compiled);
+
+    setMaterializerModeOverride('closure');
+    const closure = getResultWriterClass(schema);
+    expect(getResultWriterClass(schema)).toBe(closure);
+    expect(closure).not.toBe(compiled);
+
+    setMaterializerModeOverride(undefined);
+    expect(getResultWriterClass(schema)).toBe(compiled);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TagWriter parity (shipped closure class vs compiled-source reference)
+// ---------------------------------------------------------------------------
+
+describe('TagWriter closure vs compiled-source reference parity', () => {
+  it('writes byte-identical row-0 lanes', () => {
+    const schema = createTestSchema(createParityFields());
+    const enumLookup = resolveEnumLookupDescriptor(schema);
+    const { bufferA, bufferB, contextA, contextB } = createBufferPair(schema, 'mixed');
+
+    // Compiled reference assembled here (tests run under bun where string
+    // codegen is allowed); production tag writers never eval.
+    const classCode = generateFixedPositionWriterClass(
+      schema,
+      0,
+      'GeneratedTagWriter',
+      undefined,
+      [],
+      enumLookup,
+    ).trim();
+    const factory = new Function('helpers', 'enumLookup', classCode);
+    const CompiledTag: unknown = factory(bufferHelpers, enumLookup);
+
+    const ClosureTag = withClosureMode(() => getTagWriterClass(schema));
+    expect(getTagWriterClass(schema)).toBe(ClosureTag);
+    expect(nameOf(ClosureTag)).toBe(nameOf(CompiledTag));
+
+    const compiledWriter = constructWriter(CompiledTag, contextA);
+    const closureWriter = constructWriter(ClosureTag, contextB);
+    expect(Reflect.ownKeys(closureWriter)).toEqual(Reflect.ownKeys(compiledWriter));
+
+    runFieldScript(compiledWriter);
+    runFieldScript(closureWriter);
+
+    expectIdenticalLanes(bufferB, bufferA, [...USER_LANES, 'uint64_value']);
+  });
+});