@smoothbricks/lmao 0.2.1 → 0.2.3

package/src/lib/logBinding.ts

@@ -14,24 +14,25 @@
 
 import type { LogSchema } from './schema/LogSchema.js';
 
-// Type-only import keeps this file runtime-safe while preserving buffer shape information.
-type SpanBuffer = import('./types.js').AnySpanBuffer;
+/** Dense cold-path remap entry with schema and canonical storage property metadata. */
+export type RemappedColumn = readonly [
+  outputName: string,
+  sourceName: string,
+  schema: unknown,
+  valuesProperty: `${string}_values`,
+  nullsProperty: `${string}_nulls`,
+];
 
 /**
- * RemappedViewConstructor - Constructor type for RemappedBufferView classes.
- *
- * Generated at module composition time (cold path) by `generateRemappedBufferViewClass()`.
- * Used by prefixed modules to wrap SpanBuffer instances for Arrow conversion when
- * the module's schema columns have been renamed with a prefix.
- *
- * The constructor takes a raw SpanBuffer and returns a view that remaps column access
- * from prefixed names to unprefixed names for tree traversal during Arrow conversion.
- *
- * Per specs/lmao/01e_library_integration_pattern.md:
- * - Hot path: Library writes directly to unprefixed columns (zero overhead)
- * - Cold path: Arrow conversion uses RemappedBufferView to access via prefixed names
+ * Immutable metadata interpreted only by cold Arrow conversion.
+ * Child SpanBuffers retain their canonical schema and storage layout.
  */
-export type RemappedViewConstructor = new (buffer: SpanBuffer) => SpanBuffer;
+export interface RemapDescriptor {
+  /** Fully composed output-name to canonical source-name lookup. */
+  readonly sourceNames: Readonly<Record<string, string>>;
+  /** Dense output/source/schema entries in deterministic composition order. */
+  readonly columns: readonly RemappedColumn[];
+}
 
 /**
  * LogBinding - Everything needed for a group of ops to write logs.
@@ -47,21 +48,14 @@ export type RemappedViewConstructor = new (buffer: SpanBuffer) => SpanBuffer;
  * - 01b2_buffer_self_tuning.md - Self-tuning via SpanBufferClass.stats
  * - 01e_library_integration_pattern.md - Library prefix/remapping support
  *
- * @property logSchema - The unprefixed schema defining what columns can be written.
- *   This is the canonical schema. Column names in remappedViewClass will be prefixed versions
- *   of these field names when a prefix or column mapping has been applied.
- *
- * @property remappedViewClass - Optional RemappedBufferView class for prefixed/remapped buffers.
- *   - When present: the module's ops write to unprefixed columns, but buffers must be wrapped
- *     in this view for Arrow conversion to access them by prefixed names
- *   - When absent: buffers can be used directly without remapping
- *   - Set during module composition when prefix() or mapColumns() is applied (cold path)
- *   - Used when registering child spans to parent's tree (see op.ts)
+ * @property remapDescriptor - Optional immutable output-to-source metadata for
+ *   prefixed/remapped buffers. Ops attach the descriptor pointer to raw child
+ *   buffers; cold Arrow traversal interprets it without wrapping the buffer.
  */
 export interface LogBinding<T extends LogSchema = LogSchema> {
   /** The unprefixed schema defining what columns exist */
   readonly logSchema: T;
 
-  /** Optional RemappedBufferView class for prefixed/remapped buffers */
-  readonly remappedViewClass?: RemappedViewConstructor;
+  /** Optional immutable remapping metadata for cold Arrow conversion. */
+  readonly remapDescriptor?: RemapDescriptor;
 }

package/src/lib/op.ts

@@ -14,11 +14,24 @@
  */
 
 import type { PreEncodedEntry } from '@smoothbricks/arrow-builder';
-import type { RemappedViewConstructor } from './logBinding.js';
+import type { RemapDescriptor } from './logBinding.js';
 import type { SpanContext } from './opContext/spanContextTypes.js';
 import type { OpContext, OpContextBinding } from './opContext/types.js';
+import type {
+  ArrowExposurePlan,
+  CallsitePlan,
+  EagerColumnDescriptor,
+  PhysicalAppenders,
+} from './physicalLayoutPlan.js';
+import { getPhysicalLayoutPlan, sealCallsitePlan } from './physicalLayoutPlan.js';
 import type { Result } from './result.js';
+import { decodeRuntimeHint } from './runtimeHint.js';
+import type { LogSchema } from './schema/LogSchema.js';
 import type { SpanBufferConstructor } from './spanBuffer.js';
+import { createSpanContextClass } from './spanContext.js';
+import type { TimestampAppendPrimitive } from './traceRoot.js';
+import type { VocabularyGeneration } from './vocabularyRegistry.js';
+import type { WasmLayoutTemplate } from './wasm/wasmPhysicalLayout.js';
 
 // =============================================================================
 // OP METADATA
@@ -36,7 +49,15 @@ import type { SpanBufferConstructor } from './spanBuffer.js';
 // (package_name/package_file/git_sha) + pre-encoded UTF-8 entries for Arrow
 // dictionary building. One per defineOp; SpanBuffer/SpanContext are the other
 // two levels of the 01j Context Hierarchy.
-export interface OpMetadata {
+export interface OpCompileMetadata {
+  readonly runtimeHint: number;
+  readonly eagerColumns?: readonly string[];
+  readonly localMessageDictionary?: readonly number[];
+  /** ttsc-only startup hook that installs the source-emitted physical buffer constructor. */
+  readonly materializeSpanBufferClass?: (schema: LogSchema) => void;
+}
+
+export interface OpMetadata<T extends LogSchema = LogSchema> {
   /** Op name for metrics tracking (distinct from span names which are provided at call sites) */
   readonly name: string;
   /** Package name from package.json */
@@ -54,6 +75,18 @@ export interface OpMetadata {
   readonly package_file_entry: PreEncodedEntry;
   /** Pre-encoded git_sha for Arrow dictionary building */
   readonly git_sha_entry: PreEncodedEntry;
+  /** Startup-resolved physical layout used by span setup; absent only on raw fallback metadata. */
+  readonly _physicalLayoutPlan?: {
+    readonly SpanBufferClass: SpanBufferConstructor<T>;
+    readonly eagerColumns: EagerColumnDescriptor;
+    readonly vocabularyGeneration: VocabularyGeneration;
+    readonly localMessageDictionary: readonly number[];
+    readonly encodeLocalMessage: (globalDenseIndex: number) => number;
+    readonly wasmLayout: WasmLayoutTemplate;
+    readonly appendLogEntry: TimestampAppendPrimitive;
+    readonly arrowExposure: ArrowExposurePlan;
+    readonly appenders: PhysicalAppenders;
+  };
 }
 //#endregion smoo/lmao!n/opcontext-hierarchy
 
@@ -82,7 +115,7 @@ export interface OpMetadata {
  *
  * Phase 2 architecture:
  * - SpanBufferClass carries static schema + stats (shared by all ops from same defineOpContext)
- * - remappedViewClass only set for prefixed ops (wraps child buffers before adding to _children)
+ * - remapDescriptor is an immutable cold-path binding for prefixed/mapped ops
  * - No LogBinding - stats accessed via SpanBufferClass.stats
  *
  * @typeParam Ctx - OpContext with deps, ff, env (contravariant position)
@@ -91,21 +124,45 @@ export interface OpMetadata {
  * @typeParam E - Error type of the Result
  */
 export class Op<Ctx extends OpContext, Args extends unknown[], S, E> {
+  readonly metadata: OpMetadata;
+  readonly callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>;
+  readonly fn: (ctx: SpanContext<Ctx>, ...args: Args) => Result<S, E> | Promise<Result<S, E>>;
+  readonly _opContextBinding?: OpContextBinding<Ctx['logSchema'], Ctx['flags'], Ctx['deps'], Ctx['userCtx']>;
+
   constructor(
-    /** Op name for metrics, telemetry, and debugging */
-    readonly metadata: OpMetadata,
-    /** Op owns buffer creation - class has static schema + stats shared by all instances */
-    readonly SpanBufferClass: SpanBufferConstructor,
-    /** The user function to execute - called by span_op after context creation (can be sync or async) */
-    readonly fn: (ctx: SpanContext<Ctx>, ...args: Args) => Result<S, E> | Promise<Result<S, E>>,
-    /** Only set for prefixed ops - wraps child buffers during registration */
-    readonly remappedViewClass?: RemappedViewConstructor,
-    /**
-     * WHY: Carries the OpContextBinding from the factory that created this Op.
-     * Enables downstream consumers (defineAgentOps, OpRegistry) to extract the
-     * LMAO schema for context merging and conflict detection.
-     */
-    readonly _opContextBinding?: OpContextBinding,
-  ) {}
+    metadata: OpMetadata,
+    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
+    fn: (ctx: SpanContext<Ctx>, ...args: Args) => Result<S, E> | Promise<Result<S, E>>,
+    remapDescriptor?: RemapDescriptor,
+    opContextBinding?: OpContextBinding<Ctx['logSchema'], Ctx['flags'], Ctx['deps'], Ctx['userCtx']>,
+    runtimeHint = 0,
+    eagerColumns: readonly string[] = [],
+    localMessageDictionary: readonly number[] = Object.freeze([]),
+  ) {
+    const userContextKeys = Object.keys(opContextBinding?.ctxDefaults ?? {}).sort();
+    const layoutKey = userContextKeys.join('\u0000');
+    const capabilities = decodeRuntimeHint(runtimeHint).capabilities;
+    const SpanContextClass = createSpanContextClass<Ctx>(
+      SpanBufferClass.schema,
+      opContextBinding?.logBinding ?? { logSchema: SpanBufferClass.schema },
+      capabilities,
+      userContextKeys,
+    );
+    const physicalLayoutPlan = getPhysicalLayoutPlan<Ctx['logSchema'], Ctx>(
+      SpanBufferClass,
+      runtimeHint,
+      SpanContextClass,
+      remapDescriptor,
+      'strategy-selected',
+      layoutKey,
+      eagerColumns,
+      localMessageDictionary,
+    );
+    const resolvedMetadata = Object.freeze({ ...metadata, _physicalLayoutPlan: physicalLayoutPlan });
+    this.callsitePlan = sealCallsitePlan(physicalLayoutPlan, resolvedMetadata);
+    this.metadata = resolvedMetadata;
+    this.fn = fn;
+    this._opContextBinding = opContextBinding;
+  }
 }
 //#endregion smoo/lmao!n/op-class

package/src/lib/opContext/__tests__/retry.test.ts

@@ -23,11 +23,13 @@ import { Blocked } from '../../errors/Blocked.js';
 import { Code } from '../../errors/CodeError.js';
 import { exponentialBackoff, fixedDelay, linearBackoff, Transient, TransientError } from '../../errors/Transient.js';
 import type { OpContextOf, SpanContext } from '../../opContext/types.js';
+import { resolveEntryType } from '../../resolveMessage.js';
 import type { Result } from '../../result.js';
 import { S } from '../../schema/builder.js';
 import { defineLogSchema } from '../../schema/defineLogSchema.js';
 import { ENTRY_TYPE_SPAN_RETRY } from '../../schema/systemSchema.js';
 import { TestTracer } from '../../tracers/TestTracer.js';
+import { iterateSpanChildren } from '../../traceTopology.js';
 
 // Test schema
 const testSchema = defineLogSchema({
@@ -476,18 +478,18 @@ describe('LMAO Op Retry', () => {
       const rootBuffer = tracer.rootBuffers[0];
 
       // Get child span buffer (the span execution)
-      const childBuffers = rootBuffer._children;
-      expect(childBuffers.length).toBe(1);
-      const spanBuffer = childBuffers[0];
+      const childBuffers = Array.from(iterateSpanChildren(rootBuffer));
+      expect(childBuffers).toHaveLength(1);
+      const [spanBuffer] = childBuffers;
+      if (!spanBuffer) throw new Error('expected retry span buffer');
 
       // Check entry_type for ENTRY_TYPE_SPAN_RETRY (value 5)
       // Row 0: span-start
       // Row 1: span-ok/span-err
       // Row 2+: log entries and span-retry entries
-      const entryTypes = spanBuffer.entry_type;
       const retryEntries: number[] = [];
       for (let i = 2; i < spanBuffer._writeIndex; i++) {
-        if (entryTypes[i] === ENTRY_TYPE_SPAN_RETRY) {
+        if (resolveEntryType(spanBuffer, i) === ENTRY_TYPE_SPAN_RETRY) {
           retryEntries.push(i);
         }
       }
@@ -498,7 +500,10 @@ describe('LMAO Op Retry', () => {
       // Verify message format: retry:op:{opName}
       // Note: For inline functions, the opMetadata name comes from the parent context
       // which in this test is 'root' (the root trace name)
-      const messages = requireStringArray(spanBuffer.getColumnIfAllocated('message'), 'retry messages');
+      if (spanBuffer._messageLayoutFamily === 'static-only' || spanBuffer.message_values === undefined) {
+        throw new Error(`expected retry raw message lane, received ${spanBuffer._messageLayoutFamily}`);
+      }
+      const messages = requireStringArray(spanBuffer.message_values, 'retry messages');
       const retryAttempts = requireFloat64Array(spanBuffer.getColumnIfAllocated('retry_attempt'), 'retry attempts');
       const retryDelays = requireFloat64Array(spanBuffer.getColumnIfAllocated('retry_delay_ms'), 'retry delays');
       for (const idx of retryEntries) {
@@ -522,15 +527,15 @@ describe('LMAO Op Retry', () => {
 
       expect(tracer.rootBuffers.length).toBe(1);
       const rootBuffer = tracer.rootBuffers[0];
-      const childBuffers = rootBuffer._children;
-      expect(childBuffers.length).toBe(1);
-      const spanBuffer = childBuffers[0];
+      const childBuffers = Array.from(iterateSpanChildren(rootBuffer));
+      expect(childBuffers).toHaveLength(1);
+      const [spanBuffer] = childBuffers;
+      if (!spanBuffer) throw new Error('expected no-retry span buffer');
 
       // Check for any retry entries
-      const entryTypes = spanBuffer.entry_type;
       let retryCount = 0;
       for (let i = 0; i < spanBuffer._writeIndex; i++) {
-        if (entryTypes[i] === ENTRY_TYPE_SPAN_RETRY) {
+        if (resolveEntryType(spanBuffer, i) === ENTRY_TYPE_SPAN_RETRY) {
           retryCount++;
         }
       }
@@ -551,13 +556,13 @@ describe('LMAO Op Retry', () => {
       expect(result.success).toBe(false);
 
       const rootBuffer = tracer.rootBuffers[0];
-      const spanBuffer = rootBuffer._children[0];
+      const [spanBuffer] = iterateSpanChildren(rootBuffer);
+      if (!spanBuffer) throw new Error('expected exhausted-retry span buffer');
 
       // Check for retry entries
-      const entryTypes = spanBuffer.entry_type;
       let retryCount = 0;
       for (let i = 0; i < spanBuffer._writeIndex; i++) {
-        if (entryTypes[i] === ENTRY_TYPE_SPAN_RETRY) {
+        if (resolveEntryType(spanBuffer, i) === ENTRY_TYPE_SPAN_RETRY) {
           retryCount++;
         }
       }
@@ -583,13 +588,13 @@ describe('LMAO Op Retry', () => {
       });
 
       const rootBuffer = tracer.rootBuffers[0];
-      const spanBuffer = rootBuffer._children[0];
+      const [spanBuffer] = iterateSpanChildren(rootBuffer);
+      if (!spanBuffer) throw new Error('expected retry error-code span buffer');
 
       // Find retry entry
-      const entryTypes = spanBuffer.entry_type;
       let retryIdx = -1;
       for (let i = 2; i < spanBuffer._writeIndex; i++) {
-        if (entryTypes[i] === ENTRY_TYPE_SPAN_RETRY) {
+        if (resolveEntryType(spanBuffer, i) === ENTRY_TYPE_SPAN_RETRY) {
           retryIdx = i;
           break;
         }
@@ -664,7 +669,8 @@ describe('LMAO Op Retry', () => {
 
       // Verify tags were preserved through retry
       const rootBuffer = tracer.rootBuffers[0];
-      const spanBuffer = rootBuffer._children[0];
+      const [spanBuffer] = iterateSpanChildren(rootBuffer);
+      if (!spanBuffer) throw new Error('expected tag-preservation span buffer');
 
       // Tags are written at row 0 (span-start)
       const operations = requireStringArray(spanBuffer.getColumnIfAllocated('operation'), 'operations');
@@ -728,11 +734,11 @@ describe('LMAO Op Retry', () => {
       expect(attempts).toBe(5);
 
       // Verify 4 retry entries (attempts 1-4 failed)
-      const spanBuffer = tracer.rootBuffers[0]._children[0];
-      const entryTypes = spanBuffer.entry_type;
+      const [spanBuffer] = iterateSpanChildren(tracer.rootBuffers[0]);
+      if (!spanBuffer) throw new Error('expected multi-retry span buffer');
       let retryCount = 0;
       for (let i = 0; i < spanBuffer._writeIndex; i++) {
-        if (entryTypes[i] === ENTRY_TYPE_SPAN_RETRY) {
+        if (resolveEntryType(spanBuffer, i) === ENTRY_TYPE_SPAN_RETRY) {
           retryCount++;
         }
       }

package/src/lib/opContext/createOpGroup.ts

@@ -8,7 +8,7 @@
  * - Private fields (#columnMapping) don't affect hidden class (truly hidden, no enumeration)
  * - Ops as own properties enable direct access and predictable object shape
  * - prefix()/mapColumns() create new instances with same SpanBufferClass (shared stats)
- * - Only remappedViewClass differs between original and prefixed op instances
+ * - Only immutable remap metadata differs between original and mapped op instances
  *
  * Internal properties (_logSchema, _flags, etc.) are prefixed with underscore to avoid
  * collision with user-defined op names. Public interfaces hide these from intellisense.
@@ -16,7 +16,8 @@
  * @module opContext/createOpGroup
  */
 
-import { generateRemappedBufferViewClass } from '../library.js';
+import { createRemapDescriptor } from '../library.js';
+import type { RemapDescriptor } from '../logBinding.js';
 import { Op } from '../op.js';
 import { SYSTEM_SCHEMA_FIELD_NAMES } from '../schema/systemSchema.js';
 import type { SchemaFields } from '../schema/types.js';
@@ -36,9 +37,9 @@ import type { OpContext } from './types.js';
 
 //#region smoo/lmao!n/column-mapping-api
 // 01l "Dependencies with Column Mapping" + 01e "Column Mapping API": .prefix(name) and
-// .mapColumns({ col: 'new' | 'shared' | null }) are realized here. Each call clones the
-// OpGroup's ops with a fresh RemappedBufferView (cold-path codegen via library.ts), so the
-// hot path still writes the clean unprefixed columns; the view remaps clean->target for Arrow.
+// .mapColumns({ col: 'new' | 'shared' | null }) are composed here. Each call clones the
+// OpGroup's ops with one immutable descriptor; child buffers remain canonical and Arrow
+// interprets the descriptor only on its cold traversal path.
 // =============================================================================
 // INTERNAL HELPERS
 // =============================================================================
@@ -48,12 +49,8 @@ function getSchemaFields<Schema extends { readonly fields: SchemaFields }>(field
 }
 
 /**
- * Create reverse mapping for RemappedBufferView.
- * Input: clean -> prefixed mapping (e.g., { status: 'http_status' })
- * Output: prefixed -> clean mapping (e.g., { http_status: 'status' })
- *
- * Why reverse: RemappedBufferView wraps child buffer at registration time.
- * Arrow conversion asks for 'http_status', view needs to find 'status' in raw buffer.
+ * Create the fully composed Arrow output-to-canonical-source mapping.
+ * Input: clean -> output mapping; output: output -> clean mapping.
  */
 function createReverseMapping(mapping: Record<string, string | null | undefined>): Record<string, string> {
   const reverse: Record<string, string> = {};
@@ -69,14 +66,23 @@ function isOpInstance<Ctx extends OpContext>(value: unknown): value is Op<Ctx, u
   return value instanceof Op;
 }
 
-function copyOpsWithView<Ctx extends OpContext>(
+function copyOpsWithDescriptor<Ctx extends OpContext>(
   source: OpGroupOps<Ctx>,
   target: Record<string, unknown>,
-  remappedViewClass: ReturnType<typeof generateRemappedBufferViewClass>,
+  remapDescriptor: RemapDescriptor,
 ) {
   for (const [key, value] of Object.entries(source)) {
     if (isOpInstance<Ctx>(value)) {
-      target[key] = new Op(value.metadata, value.SpanBufferClass, value.fn, remappedViewClass, value._opContextBinding);
+      target[key] = new Op(
+        value.metadata,
+        value.callsitePlan.SpanBufferClass,
+        value.fn,
+        remapDescriptor,
+        value._opContextBinding,
+        value.callsitePlan.runtimeHint,
+        value.callsitePlan.eagerColumns.names,
+        value.callsitePlan.localMessageDictionary,
+      );
     }
   }
 }
@@ -92,12 +98,12 @@ function assertGroupCarriesOps<Ctx extends OpContext, Ops extends OpGroupOps<Ctx
   }
 }
 
-function cloneOpsWithView<Ctx extends OpContext, Ops extends OpGroupOps<Ctx>>(
+function cloneOpsWithDescriptor<Ctx extends OpContext, Ops extends OpGroupOps<Ctx>>(
   source: Ops,
-  remappedViewClass: ReturnType<typeof generateRemappedBufferViewClass>,
+  remapDescriptor: RemapDescriptor,
 ): Ops {
   const cloned: Record<string, unknown> = {};
-  copyOpsWithView<Ctx>(source, cloned, remappedViewClass);
+  copyOpsWithDescriptor<Ctx>(source, cloned, remapDescriptor);
   assertGroupCarriesOps<Ctx, Ops>(cloned, source);
   return cloned;
 }
@@ -105,6 +111,7 @@ function cloneOpsWithView<Ctx extends OpContext, Ops extends OpGroupOps<Ctx>>(
 function prefixContributedSchema<T extends SchemaFields, P extends string>(fields: T, prefix: P): PrefixedSchema<T, P> {
   const result: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(fields)) {
+    if (SYSTEM_SCHEMA_FIELD_NAMES.has(key)) continue;
     result[`${prefix}_${key}`] = value;
   }
   assertMappedSchema<PrefixedSchema<T, P>>(result);
@@ -226,7 +233,7 @@ function validateAllOpNames(ops: Record<string, unknown>): void {
  * 2. Ops spread as own properties for direct access (`.request` not `.ops.request`)
  * 3. Prototype methods (prefix/mapColumns) shared across instances
  * 4. Same SpanBufferClass preserved across prefix() calls (shared schema + stats)
- * 5. Only remappedViewClass differs between original and prefixed ops
+ * 5. Only immutable remap metadata differs between original and mapped ops
  *
  * Structure enables V8 optimization:
  * - All OpGroup instances with same ops have same hidden class
@@ -271,16 +278,14 @@ class OpGroupImpl<Ctx extends OpContext, Ops extends OpGroupOps<Ctx>> implements
       ? prefixMapping(this.#columnMapping, p)
       : buildPrefixMapping(this._logSchema._columnNames, p);
 
-    // Generate RemappedBufferView for this prefix
-    // Why reverse mapping: Arrow conversion asks for 'http_status', needs to find 'status'
     const reverseMapping = createReverseMapping(newMapping);
-    const remappedViewClass = generateRemappedBufferViewClass(reverseMapping);
+    const remapDescriptor = createRemapDescriptor(this._logSchema, reverseMapping);
 
     // Create new OpGroup with prefixed ops
     const newGroup = new MappedOpGroupImpl<Ctx, PrefixedSchema<Ctx['logSchema']['fields'], P>, Ops>(
       this._logSchema,
       this._flags,
-      cloneOpsWithView<Ctx, Ops>(this.#ops, remappedViewClass),
+      cloneOpsWithDescriptor<Ctx, Ops>(this.#ops, remapDescriptor),
       newMapping,
       prefixContributedSchema<Ctx['logSchema']['fields'], P>(getSchemaFields(this._logSchema), p),
     );
@@ -295,9 +300,8 @@ class OpGroupImpl<Ctx extends OpContext, Ops extends OpGroupOps<Ctx>> implements
     // Override/extend the existing mapping with new mapping
     const newMapping = { ...this.#columnMapping, ...mapping };
 
-    // Generate RemappedBufferView for this mapping
     const reverseMapping = createReverseMapping(newMapping);
-    const remappedViewClass = generateRemappedBufferViewClass(reverseMapping);
+    const remapDescriptor = createRemapDescriptor(this._logSchema, reverseMapping);
 
     // Build contributed schema from original fields with new mapping
     const newContributed = buildContributedSchema<Ctx['logSchema']['fields'], M>(
@@ -309,7 +313,7 @@ class OpGroupImpl<Ctx extends OpContext, Ops extends OpGroupOps<Ctx>> implements
     const newGroup = new MappedOpGroupImpl<Ctx, MappedSchema<Ctx['logSchema']['fields'], M>, Ops>(
       this._logSchema,
       this._flags,
-      cloneOpsWithView<Ctx, Ops>(this.#ops, remappedViewClass),
+      cloneOpsWithDescriptor<Ctx, Ops>(this.#ops, remapDescriptor),
       newMapping,
       newContributed,
     );
@@ -363,9 +367,8 @@ class MappedOpGroupImpl<Ctx extends OpContext, ContributedSchema extends SchemaF
     // Apply prefix to the current mapping's target names
     const newMapping = prefixMapping(this.#columnMapping, p);
 
-    // Generate RemappedBufferView
     const reverseMapping = createReverseMapping(newMapping);
-    const remappedViewClass = generateRemappedBufferViewClass(reverseMapping);
+    const remapDescriptor = createRemapDescriptor(this._logSchema, reverseMapping);
 
     // Build new contributed schema by prefixing current contributed schema
     const newContributed = prefixContributedSchema(this._contributedSchema, p);
@@ -374,7 +377,7 @@ class MappedOpGroupImpl<Ctx extends OpContext, ContributedSchema extends SchemaF
     const newGroup = new MappedOpGroupImpl<Ctx, PrefixedSchema<ContributedSchema, P>, Ops>(
       this._logSchema,
       this._flags,
-      cloneOpsWithView<Ctx, Ops>(this.#ops, remappedViewClass),
+      cloneOpsWithDescriptor<Ctx, Ops>(this.#ops, remapDescriptor),
       newMapping,
       newContributed,
     );
@@ -389,9 +392,8 @@ class MappedOpGroupImpl<Ctx extends OpContext, ContributedSchema extends SchemaF
     // Override/extend the existing mapping
     const newMapping = { ...this.#columnMapping, ...mapping };
 
-    // Generate RemappedBufferView
     const reverseMapping = createReverseMapping(newMapping);
-    const remappedViewClass = generateRemappedBufferViewClass(reverseMapping);
+    const remapDescriptor = createRemapDescriptor(this._logSchema, reverseMapping);
 
     // Build contributed schema from current contributed fields so chained maps stay typed to the public surface.
     const newContributed = buildContributedSchema(this._contributedSchema, mapping);
@@ -400,7 +402,7 @@ class MappedOpGroupImpl<Ctx extends OpContext, ContributedSchema extends SchemaF
     const newGroup = new MappedOpGroupImpl<Ctx, MappedSchema<ContributedSchema, M>, Ops>(
       this._logSchema,
       this._flags,
-      cloneOpsWithView<Ctx, Ops>(this.#ops, remappedViewClass),
+      cloneOpsWithDescriptor<Ctx, Ops>(this.#ops, remapDescriptor),
       newMapping,
       newContributed,
     );