@smoothbricks/lmao 0.2.2 → 0.3.0

package/src/lib/spanContext.ts

@@ -12,9 +12,8 @@
  *
  * SpanContext is implemented as a class factory pattern:
  * - `createSpanContextClass()` returns a class that closes over schema/logBinding
- * - Child contexts use `Object.create(parent)` for prototype inheritance
- * - User properties (deps, ff, env) are inherited via prototype chain
- * - Context overrides work by setting own properties that shadow inherited ones
+ * - Child contexts are constructed directly from the frozen CallsitePlan
+ * - User properties are copied from the parent only when an override context is requested
  *
  * ## Method Binding for Destructuring
  *
@@ -25,22 +24,30 @@
  * - const { span, ok, err } = ctx; // Just works!
  */
 
-import type { TagWriter } from './codegen/fixedPositionWriterGenerator.js';
-import { createTagWriter } from './codegen/fixedPositionWriterGenerator.js';
+import type { TagWriter, WriterState } from './codegen/fixedPositionWriterGenerator.js';
 import {
   createSpanLogger as createSpanLoggerFromGenerator,
   type FluentLogEntry,
   type ScopeUpdate,
   type SpanLoggerImpl,
 } from './codegen/spanLoggerGenerator.js';
-import { Blocked } from './errors/Blocked.js';
 import type { RetryPolicy } from './errors/retry-policy.js';
 import { TransientError } from './errors/Transient.js';
-import type { RemappedViewConstructor } from './logBinding.js';
-import { Op } from './op.js';
+import type { Op } from './op.js';
 import type { OpContext, OpMetadata, SpanContext, SpanFn, SpanLogger, SpanSyncFn } from './opContext/types.js';
+import type { CallsitePlan, PhysicalLayoutPlan } from './physicalLayoutPlan.js';
 import { Err, hasErrorCode, Ok, type Result } from './result.js';
-import type { FeatureFlagEvaluator, InferFeatureFlagsWithContext } from './schema/evaluator.js';
+import {
+  RUNTIME_HINT_DEPS,
+  RUNTIME_HINT_FF,
+  RUNTIME_HINT_FULL_CAPABILITIES,
+  RUNTIME_HINT_LOG,
+  RUNTIME_HINT_RESULT,
+  RUNTIME_HINT_SCOPE,
+  RUNTIME_HINT_SPAN,
+  RUNTIME_HINT_TAG,
+} from './runtimeHint.js';
+import type { FeatureFlagEvaluator, FlagEvaluator, InferFeatureFlagsWithContext } from './schema/evaluator.js';
 import {
   ENTRY_TYPE_SPAN_ERR,
   ENTRY_TYPE_SPAN_EXCEPTION,
@@ -48,8 +55,7 @@ import {
   ENTRY_TYPE_SPAN_RETRY,
 } from './schema/systemSchema.js';
 import type { InferSchema, LogSchema } from './schema/types.js';
-import type { SpanBufferConstructor } from './spanBuffer.js';
-import type { LogBinding, SpanBuffer } from './types.js';
+import type { AnySpanBuffer, LogBinding, SpanBuffer } from './types.js';
 
 // Note: TraceRoot.writeSpanStart() is used instead of direct timestamp writes.
 // The platform-specific TraceRoot (traceRoot.es.ts or traceRoot.node.ts) handles
@@ -98,14 +104,23 @@ type SpanDispatchFn<Ctx extends OpContext, Args extends unknown[] = unknown[], S
 ) => Result<S, E> | Promise<Result<S, E>>;
 
 type SpanDispatchTarget<Ctx extends OpContext> = {
-  readonly SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>;
-  readonly remappedViewClass: RemappedViewConstructor | undefined;
+  readonly callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>;
   readonly opMetadata: OpMetadata;
   readonly fn: SpanDispatchFn<Ctx>;
 };
 
+function isOpLike(value: unknown): value is Op<OpContext, unknown[], unknown, unknown> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof Reflect.get(value, 'fn') === 'function' &&
+    typeof Reflect.get(value, 'callsitePlan') === 'object' &&
+    typeof Reflect.get(value, 'metadata') === 'object'
+  );
+}
+
 function isOpInstance<Ctx extends OpContext>(value: unknown): value is Op<Ctx, unknown[], unknown, unknown> {
-  return value instanceof Op;
+  return isOpLike(value);
 }
 
 // WHY: resolveSpanTarget() accepts either an Op instance or a raw span
@@ -115,60 +130,22 @@ function isSpanDispatchFn<Ctx extends OpContext>(value: unknown): value is SpanD
   return typeof value === 'function';
 }
 
-function isSpanBufferConstructorForSchema<T extends LogSchema>(
-  value: unknown,
-  schema: T,
-): value is SpanBufferConstructor<T> {
-  return (
-    typeof value === 'function' &&
-    Reflect.get(value, 'schema') === schema &&
-    typeof Reflect.get(value, 'stats') === 'object'
-  );
-}
-
-function getBufferConstructor<T extends LogSchema>(buffer: SpanBuffer<T>): SpanBufferConstructor<T> {
-  const ctor = buffer.constructor;
-  if (!isSpanBufferConstructorForSchema(ctor, buffer._logSchema)) {
-    throw new TypeError('Span buffer constructor does not match the buffer schema');
-  }
-  return ctor;
-}
-
-function isSpanBufferForSchema<T extends LogSchema>(buffer: unknown, schema: T): buffer is SpanBuffer<T> {
-  return (
-    typeof buffer === 'object' &&
-    buffer !== null &&
-    Reflect.get(buffer, '_logSchema') === schema &&
-    isSpanBufferConstructorForSchema(Reflect.get(buffer, 'constructor'), schema)
-  );
-}
-
 function isSpanContextInstance<Ctx extends OpContext>(value: unknown): value is SpanContextInstance<Ctx> {
   return (
     isSpanContext<Ctx>(value) &&
+    Reflect.has(value, '_spanBuffer') &&
     Reflect.has(value, '_buffer') &&
-    Reflect.has(value, '_spanLogger') &&
-    Reflect.has(value, '_schema')
+    Reflect.has(value, '_schema') &&
+    Reflect.has(value, '_logBinding') &&
+    Reflect.has(value, '_physicalLayoutPlan')
   );
 }
 
-function createInheritedContext<Ctx extends OpContext>(parent: SpanContextInstance<Ctx>): SpanContextInstance<Ctx> {
-  const child: unknown = Object.create(parent);
-  if (!isSpanContextInstance<Ctx>(child)) {
-    throw new TypeError('Failed to create child span context');
+function asSpanContextInstance<Ctx extends OpContext>(value: object): SpanContextInstance<Ctx> {
+  if (!isSpanContextInstance<Ctx>(value)) {
+    throw new TypeError('Callsite plan created an invalid child span context');
   }
-  return child;
-}
-
-function createInheritedContextWithOverrides<Ctx extends OpContext>(
-  parent: SpanContextInstance<Ctx>,
-  overrides: object,
-): SpanContextInstance<Ctx> {
-  const child: unknown = Object.assign(Object.create(parent), overrides);
-  if (!isSpanContextInstance<Ctx>(child)) {
-    throw new TypeError('Failed to create overridden child span context');
-  }
-  return child;
+  return value;
 }
 
 function readStringArgument(args: IArguments, index: number, label: string): string {
@@ -181,12 +158,12 @@ function readStringArgument(args: IArguments, index: number, label: string): str
 
 function resolveSpanTarget<Ctx extends OpContext>(
   value: unknown,
-  fallbackBuffer: SpanBuffer<Ctx['logSchema']>,
+  fallbackPlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+  fallbackMetadata: OpMetadata,
 ): SpanDispatchTarget<Ctx> {
   if (isOpInstance<Ctx>(value)) {
     return {
-      SpanBufferClass: value.SpanBufferClass,
-      remappedViewClass: value.remappedViewClass,
+      callsitePlan: value.callsitePlan,
       opMetadata: value.metadata,
       fn: value.fn,
     };
@@ -197,13 +174,21 @@ function resolveSpanTarget<Ctx extends OpContext>(
   }
 
   return {
-    SpanBufferClass: getBufferConstructor(fallbackBuffer),
-    remappedViewClass: undefined,
-    opMetadata: fallbackBuffer._opMetadata,
+    callsitePlan: fallbackPlan,
+    opMetadata: fallbackMetadata,
     fn: value,
   };
 }
 
+function isSynchronousResult<S, E>(value: Result<S, E> | PromiseLike<Result<S, E>>): value is Result<S, E> {
+  return value instanceof Ok || value instanceof Err;
+}
+
+function getRetryableError<S, E>(result: Result<S, E>, attempt: number): TransientError<string, unknown> | undefined {
+  if (!(result instanceof Err) || !(result.error instanceof TransientError)) return undefined;
+  return attempt < result.error.policy.maxAttempts ? result.error : undefined;
+}
+
 // =============================================================================
 // Helper Functions
 // =============================================================================
@@ -224,22 +209,13 @@ function resolveSpanTarget<Ctx extends OpContext>(
  */
 export function writeSpanStart<T extends LogSchema>(buffer: SpanBuffer<T>, spanName: string): void {
   // Delegate to TraceRoot - platform-specific implementation handles timestamps
-  buffer._traceRoot.writeSpanStart(buffer, spanName);
+  buffer._traceRoot._writeSpanStart(buffer._traceRoot, buffer, spanName);
 }
 //#endregion smoo/lmao!n/lmao-entry-span-lifecycle-entry-types.start
 
-/**
- * Create a SpanLogger for the given buffer.
- *
- * Per specs/lmao/01i_span_scope_attributes.md: Scope values are stored directly on buffer._scopeValues.
- * The SpanLogger reads/writes scope via buffer._scopeValues - no separate Scope class needed.
- *
- * @param schema - Tag attribute schema with field definitions
- * @param buffer - SpanBuffer to write entries to (per-span instance)
- * @returns SpanLogger with typed methods matching schema
- */
-export function createSpanLogger<T extends LogSchema>(schema: T, buffer: SpanBuffer<T>): SpanLoggerImpl<T> {
-  return createSpanLoggerFromGenerator(schema, buffer);
+/** Create a SpanLogger bound to an existing SpanContext writer state. */
+export function createSpanLogger<T extends LogSchema>(schema: T, state: WriterState): SpanLoggerImpl<T> {
+  return createSpanLoggerFromGenerator(schema, state);
 }
 
 //#region smoo/lmao!n/op-retry.delay
@@ -302,9 +278,9 @@ function writeRetryEntry<T extends LogSchema>(
   // Get current write index and advance for next write
   const index = buffer._writeIndex;
 
-  // Write entry via TraceRoot for timestamp handling
-  // TraceRoot.writeLogEntry writes timestamp and entry_type at the given index
-  buffer._traceRoot.writeLogEntry(buffer, ENTRY_TYPE_SPAN_RETRY);
+  const traceRoot = buffer._traceRoot;
+  const appendLogEntry = buffer._opMetadata._physicalLayoutPlan?.appendLogEntry ?? traceRoot._appendLogEntry;
+  appendLogEntry(traceRoot, buffer, ENTRY_TYPE_SPAN_RETRY);
 
   // Write retry-specific message: retry:op:{opName} for prefix-based querying
   const opName = buffer._opMetadata?.name ?? 'unknown';
@@ -332,68 +308,211 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-/**
- * Execute function with retry loop for TransientError handling.
- *
- * Per plan 19-03: Op class handles retry loop internally.
- * - TransientError from op body triggers retry based on error.policy
- * - Retry respects maxAttempts from TransientError.policy
- * - span-retry entry written for each transient failure
- * - Only final result written as span-ok or span-err
- * - BlockedError returns immediately without retry
- *
- * @param buffer - SpanBuffer to write retry entries to
- * @param fn - Function to execute (may be retried)
- * @returns Final result (success, non-transient error, or exhausted transient error)
- */
-async function executeWithRetry<T extends LogSchema, S, E>(
-  buffer: SpanBuffer<T>,
-  fn: () => Result<S, E> | Promise<Result<S, E>>,
+async function executeWithRetry0<Ctx extends OpContext, S, E>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (ctx: SpanContext<Ctx>) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
 ): Promise<Result<S, E>> {
   let attempt = 0;
-
   while (true) {
     attempt++;
+    const result = await fn(ctx);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-    // Execute the function
-    const result = await fn();
-
-    // Success - return immediately
-    if (result instanceof Ok) {
-      return result;
-    }
-
-    // Error result - check error type for retry behavior
-    const error = (result as Err<E>).error;
+async function executeWithRetry1<Ctx extends OpContext, S, E, A1>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (ctx: SpanContext<Ctx>, a1: A1) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-    // BlockedError - return immediately, no retry
-    if (error instanceof Blocked) {
-      return result;
-    }
+async function executeWithRetry2<Ctx extends OpContext, S, E, A1, A2>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+  a2: A2,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1, a2);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-    // TransientError - check if we should retry
-    if (error instanceof TransientError) {
-      const { policy } = error;
+async function executeWithRetry3<Ctx extends OpContext, S, E, A1, A2, A3>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+  a2: A2,
+  a3: A3,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1, a2, a3);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-      // Check attempt limit (maxAttempts includes initial attempt)
-      if (attempt >= policy.maxAttempts) {
-        // Exhausted - return final error
-        return result;
-      }
+async function executeWithRetry4<Ctx extends OpContext, S, E, A1, A2, A3, A4>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+  a2: A2,
+  a3: A3,
+  a4: A4,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1, a2, a3, a4);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-      // Calculate delay based on policy and attempt number
-      const delay = calculateDelay(policy, attempt);
+async function executeWithRetry5<Ctx extends OpContext, S, E, A1, A2, A3, A4, A5>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+  a2: A2,
+  a3: A3,
+  a4: A4,
+  a5: A5,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1, a2, a3, a4, a5);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-      // Write span-retry entry to buffer for observability
-      writeRetryEntry(buffer, attempt, error, delay);
+async function executeWithRetry6<Ctx extends OpContext, S, E, A1, A2, A3, A4, A5, A6>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+  a2: A2,
+  a3: A3,
+  a4: A4,
+  a5: A5,
+  a6: A6,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1, a2, a3, a4, a5, a6);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-      // Wait before retry
-      await sleep(delay);
-      continue;
-    }
+async function executeWithRetry7<Ctx extends OpContext, S, E, A1, A2, A3, A4, A5, A6, A7>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (
+    ctx: SpanContext<Ctx>,
+    a1: A1,
+    a2: A2,
+    a3: A3,
+    a4: A4,
+    a5: A5,
+    a6: A6,
+    a7: A7,
+  ) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+  a2: A2,
+  a3: A3,
+  a4: A4,
+  a5: A5,
+  a6: A6,
+  a7: A7,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1, a2, a3, a4, a5, a6, a7);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
+  }
+}
 
-    // Non-transient error - return immediately
-    return result;
+async function executeWithRetry8<Ctx extends OpContext, S, E, A1, A2, A3, A4, A5, A6, A7, A8>(
+  buffer: SpanBuffer<Ctx['logSchema']>,
+  fn: (
+    ctx: SpanContext<Ctx>,
+    a1: A1,
+    a2: A2,
+    a3: A3,
+    a4: A4,
+    a5: A5,
+    a6: A6,
+    a7: A7,
+    a8: A8,
+  ) => Result<S, E> | Promise<Result<S, E>>,
+  ctx: SpanContext<Ctx>,
+  a1: A1,
+  a2: A2,
+  a3: A3,
+  a4: A4,
+  a5: A5,
+  a6: A6,
+  a7: A7,
+  a8: A8,
+): Promise<Result<S, E>> {
+  let attempt = 0;
+  while (true) {
+    attempt++;
+    const result = await fn(ctx, a1, a2, a3, a4, a5, a6, a7, a8);
+    if (!(result instanceof Err) || !(result.error instanceof TransientError)) return result;
+    if (attempt >= result.error.policy.maxAttempts) return result;
+    const delay = calculateDelay(result.error.policy, attempt);
+    writeRetryEntry(buffer, attempt, result.error, delay);
+    await sleep(delay);
   }
 }
 //#endregion smoo/lmao!n/op-retry.loop
@@ -411,12 +530,17 @@ async function executeWithRetry<T extends LogSchema, S, E>(
  * @param buffer - SpanBuffer to write to
  * @param result - The result returned by the span function
  */
+function writeSpanEndEntry<T extends LogSchema>(buffer: SpanBuffer<T>, entryType: number): void {
+  const appenders = buffer._opMetadata._physicalLayoutPlan?.appenders;
+  if (appenders === undefined) throw new TypeError('SpanBuffer metadata is missing physical lifecycle appenders');
+  appenders.writeSpanEnd(buffer, entryType);
+}
+
 export function writeSpanEnd<T extends LogSchema, S, E>(buffer: SpanBuffer<T>, result: Result<S, E>): void {
-  // Write entry_type and timestamp via TraceRoot (platform-specific)
   if (result instanceof Ok) {
-    buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_OK);
+    writeSpanEndEntry(buffer, ENTRY_TYPE_SPAN_OK);
   } else if (result instanceof Err) {
-    buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_ERR);
+    writeSpanEndEntry(buffer, ENTRY_TYPE_SPAN_ERR);
     // Write error_code if the error has a code property
     if (hasErrorCode(result.error)) {
       buffer.error_code(1, result.error.code);
@@ -432,147 +556,142 @@ export function writeSpanEnd<T extends LogSchema, S, E>(buffer: SpanBuffer<T>, r
 //#region smoo/lmao!n/spancontext-type
 /**
  * Constructor type for SpanContext classes created by createSpanContextClass.
- * Takes buffer, schema, spanLogger, tag directly (no temp object allocation).
- *
- * 01j "SpanContext Type Definition": the runtime SpanContext shape, parameterised by a single
- * bundled OpContext (logSchema/flags/deps/...) rather than separate Schema/Deps/FF/Extra params,
- * and SpanFn realized as the monomorphic span0-span8 overloads + variadic span() dispatcher.
+ * The instance itself becomes the writer state after its core fields are assigned.
  */
-export type SpanContextClass<Ctx extends OpContext> = new (
+export type SpanContextClass<Ctx extends OpContext = OpContext> = new (
   buffer: SpanBuffer<Ctx['logSchema']>,
   schema: Ctx['logSchema'],
-  spanLogger: SpanLoggerImpl<Ctx['logSchema']>,
-  tag: TagWriter<Ctx['logSchema']>,
+  callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+  contextSource?: Record<string, unknown>,
+  contextOverrides?: Record<string, unknown>,
+  deps?: Record<string, unknown>,
+  ffSource?: FlagEvaluator<Ctx> | (FeatureFlagEvaluator<Ctx> & InferFeatureFlagsWithContext<Ctx>),
 ) => SpanContextInstance<Ctx>;
 
 /**
  * Instance type of SpanContext class - what ops actually receive.
  * This is a type alias that extends the public SpanContext with internal properties.
  */
-export type SpanContextInstance<Ctx extends OpContext> = SpanContext<Ctx> & {
-  // Internal properties
-  _buffer: SpanBuffer<Ctx['logSchema']>;
-  _schema: Ctx['logSchema'];
-  _spanLogger: SpanLoggerImpl<Ctx['logSchema']>;
-  _logBinding: LogBinding;
-
-  // Internal methods
-  _newCtx0(): SpanContextInstance<Ctx>;
-  _newCtx1(overrides: object): SpanContextInstance<Ctx>;
-  _spanPre(
-    childCtx: SpanContextInstance<Ctx>,
-    line: number,
-    name: string,
-    SpanBufferClass: SpanBufferConstructor,
-    remappedViewClass: import('./logBinding.js').RemappedViewConstructor | undefined,
-    opMetadata: import('./opContext/opTypes.js').OpMetadata,
-  ): SpanContextInstance<Ctx>;
-  _spanException(buffer: SpanBuffer<Ctx['logSchema']>, error: unknown): void;
-
-  // Monomorphic span methods (span0-span8)
-  // Transformer emits: ctx.span0(line, name, ctx, SpanBufferClass, remappedViewClass, opMetadata, fn, ...args)
-  spanSync0<S, E>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (ctx: SpanContext<Ctx>) => Result<S, E>,
-  ): Result<S, E>;
-  span0<S, E>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: import('./logBinding.js').RemappedViewConstructor | undefined,
-    opMetadata: import('./opContext/opTypes.js').OpMetadata,
-    fn: (ctx: SpanContext<Ctx>) => Result<S, E> | Promise<Result<S, E>>,
-  ): Promise<Result<S, E>>;
-  span1<S, E, A1>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (ctx: SpanContext<Ctx>, a1: A1) => Result<S, E> | Promise<Result<S, E>>,
-    a1: A1,
-  ): Promise<Result<S, E>>;
-  span2<S, E, A1, A2>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2) => Result<S, E> | Promise<Result<S, E>>,
-    a1: A1,
-    a2: A2,
-  ): Promise<Result<S, E>>;
-  span3<S, E, A1, A2, A3>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3) => Result<S, E> | Promise<Result<S, E>>,
-    a1: A1,
-    a2: A2,
-    a3: A3,
-  ): Promise<Result<S, E>>;
-  span4<S, E, A1, A2, A3, A4>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4) => Result<S, E> | Promise<Result<S, E>>,
-    a1: A1,
-    a2: A2,
-    a3: A3,
-    a4: A4,
-  ): Promise<Result<S, E>>;
-  span5<S, E, A1, A2, A3, A4, A5>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => Result<S, E> | Promise<Result<S, E>>,
-    a1: A1,
-    a2: A2,
-    a3: A3,
-    a4: A4,
-    a5: A5,
-  ): Promise<Result<S, E>>;
-  span6<S, E, A1, A2, A3, A4, A5, A6>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => Result<S, E> | Promise<Result<S, E>>,
-    a1: A1,
-    a2: A2,
-    a3: A3,
-    a4: A4,
-    a5: A5,
-    a6: A6,
-  ): Promise<Result<S, E>>;
-  span7<S, E, A1, A2, A3, A4, A5, A6, A7>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (
-      ctx: SpanContext<Ctx>,
+export type SpanContextInstance<Ctx extends OpContext> = SpanContext<Ctx> &
+  WriterState & {
+    _spanBuffer: SpanBuffer<Ctx['logSchema']>;
+    _schema: Ctx['logSchema'];
+    _spanLogger: SpanLoggerImpl<Ctx['logSchema']>;
+    _logBinding: LogBinding;
+    _physicalLayoutPlan: CallsitePlan<Ctx['logSchema'], Ctx>;
+
+    // Internal methods
+    _newCtx0(): SpanContextInstance<Ctx>;
+    _newCtx1(overrides: object): SpanContextInstance<Ctx>;
+    _spanPre(
+      childCtx: SpanContextInstance<Ctx>,
+      line: number,
+      name: string | number,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      opMetadata: OpMetadata,
+    ): SpanContextInstance<Ctx>;
+    _spanException(buffer: SpanBuffer<Ctx['logSchema']>, error: unknown): void;
+
+    spanSync0<S, E>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>) => Result<S, E> | Promise<Result<S, E>>,
+    ): Result<S, E>;
+    span0<S, E>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>) => Result<S, E> | Promise<Result<S, E>>,
+    ): Promise<Result<S, E>>;
+    span1<S, E, A1>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>, a1: A1) => Result<S, E> | Promise<Result<S, E>>,
+      a1: A1,
+    ): Promise<Result<S, E>>;
+    span2<S, E, A1, A2>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2) => Result<S, E> | Promise<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+    ): Promise<Result<S, E>>;
+    span3<S, E, A1, A2, A3>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3) => Result<S, E> | Promise<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+    ): Promise<Result<S, E>>;
+    span4<S, E, A1, A2, A3, A4>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4) => Result<S, E> | Promise<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+    ): Promise<Result<S, E>>;
+    span5<S, E, A1, A2, A3, A4, A5>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => Result<S, E> | Promise<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+    ): Promise<Result<S, E>>;
+    span6<S, E, A1, A2, A3, A4, A5, A6>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (
+        ctx: SpanContext<Ctx>,
+        a1: A1,
+        a2: A2,
+        a3: A3,
+        a4: A4,
+        a5: A5,
+        a6: A6,
+      ) => Result<S, E> | Promise<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+      a6: A6,
+    ): Promise<Result<S, E>>;
+    span7<S, E, A1, A2, A3, A4, A5, A6, A7>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (
+        ctx: SpanContext<Ctx>,
+        a1: A1,
+        a2: A2,
+        a3: A3,
+        a4: A4,
+        a5: A5,
+        a6: A6,
+        a7: A7,
+      ) => Result<S, E> | Promise<Result<S, E>>,
       a1: A1,
       a2: A2,
       a3: A3,
@@ -580,24 +699,23 @@ export type SpanContextInstance<Ctx extends OpContext> = SpanContext<Ctx> & {
       a5: A5,
       a6: A6,
       a7: A7,
-    ) => Result<S, E> | Promise<Result<S, E>>,
-    a1: A1,
-    a2: A2,
-    a3: A3,
-    a4: A4,
-    a5: A5,
-    a6: A6,
-    a7: A7,
-  ): Promise<Result<S, E>>;
-  span8<S, E, A1, A2, A3, A4, A5, A6, A7, A8>(
-    line: number,
-    name: string,
-    childCtx: SpanContextInstance<Ctx>,
-    SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-    remappedViewClass: RemappedViewConstructor | undefined,
-    opMetadata: OpMetadata,
-    fn: (
-      ctx: SpanContext<Ctx>,
+    ): Promise<Result<S, E>>;
+    span8<S, E, A1, A2, A3, A4, A5, A6, A7, A8>(
+      line: number,
+      name: string | number,
+      childCtx: SpanContextInstance<Ctx>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (
+        ctx: SpanContext<Ctx>,
+        a1: A1,
+        a2: A2,
+        a3: A3,
+        a4: A4,
+        a5: A5,
+        a6: A6,
+        a7: A7,
+        a8: A8,
+      ) => Result<S, E, Ctx['logSchema']> | Promise<Result<S, E, Ctx['logSchema']>>,
       a1: A1,
       a2: A2,
       a3: A3,
@@ -606,32 +724,45 @@ export type SpanContextInstance<Ctx extends OpContext> = SpanContext<Ctx> & {
       a6: A6,
       a7: A7,
       a8: A8,
-    ) => Result<S, E, Ctx['logSchema']> | Promise<Result<S, E, Ctx['logSchema']>>,
-    a1: A1,
-    a2: A2,
-    a3: A3,
-    a4: A4,
-    a5: A5,
-    a6: A6,
-    a7: A7,
-    a8: A8,
-  ): Promise<Result<S, E, Ctx['logSchema']>>;
-};
+    ): Promise<Result<S, E, Ctx['logSchema']>>;
+  };
 //#endregion smoo/lmao!n/spancontext-type
 
 // =============================================================================
 // SpanContext Class Factory
 // =============================================================================
 
-/**
- * Create a SpanContext class for the given schema and logBinding.
+const spanContextClassCaches = new WeakMap<LogBinding, Map<string, unknown>>();
+
+function isSpanContextClass<Ctx extends OpContext>(value: unknown): value is SpanContextClass<Ctx> {
+  return typeof value === 'function';
+}
+
+export function isPhysicalLayoutPlanForContext<Ctx extends OpContext>(
+  value: unknown,
+  schema: Ctx['logSchema'],
+): value is PhysicalLayoutPlan<Ctx['logSchema'], Ctx> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    Reflect.get(value, 'schema') === schema &&
+    isSpanContextClass<Ctx>(Reflect.get(value, 'SpanContextClass'))
+  );
+}
+
+function isFlagEvaluatorForContext<Ctx extends OpContext>(value: unknown): value is FlagEvaluator<Ctx> {
+  return typeof value === 'object' && value !== null && typeof Reflect.get(value, 'forContext') === 'function';
+}
+
+/**
+ * Create a SpanContext class for the given schema and logBinding.
  *
  * The returned class:
  * - Closes over schema/logBinding (available to all methods)
  * - Constructor takes buffer, spanLogger, tag directly (no temp object allocation)
  * - Uses prototype methods for internal methods (_spanPre, _spanException, span0-span8)
- * - Supports context inheritance via Object.create(parent) for child spans
- * - Supports context overrides via own properties shadowing inherited ones
+ * - Reuses the parent context as the zero-override source without allocating a carrier object
+ * - Context overrides use the plan's schema-specific context factory
  *
  * @param schemaOnly - Tag attribute schema
  * @param logBinding - LogBinding with schema and stats
@@ -640,61 +771,111 @@ export type SpanContextInstance<Ctx extends OpContext> = SpanContext<Ctx> & {
 export function createSpanContextClass<Ctx extends OpContext>(
   _schemaOnly: Ctx['logSchema'],
   logBinding: LogBinding,
+  capabilities = RUNTIME_HINT_FULL_CAPABILITIES,
+  userContextKeys: readonly string[] = [],
 ): SpanContextClass<Ctx> {
+  const canonicalUserContextKeys = [...userContextKeys].sort();
+  const layoutKey = canonicalUserContextKeys.join('\u0000');
+  const cacheKey = `${capabilities}:${layoutKey}`;
+  let cache = spanContextClassCaches.get(logBinding);
+  if (!cache) {
+    cache = new Map();
+    spanContextClassCaches.set(logBinding, cache);
+  }
+  const cached = cache.get(cacheKey);
+  if (isSpanContextClass<Ctx>(cached)) return cached;
+
+  const hasTag = (capabilities & RUNTIME_HINT_TAG) !== 0;
+  const hasLog = (capabilities & RUNTIME_HINT_LOG) !== 0;
+  const hasFf = (capabilities & RUNTIME_HINT_FF) !== 0;
+  const hasSpan = (capabilities & RUNTIME_HINT_SPAN) !== 0;
+  const hasResult = (capabilities & RUNTIME_HINT_RESULT) !== 0;
+  const hasScope = (capabilities & RUNTIME_HINT_SCOPE) !== 0;
+  const hasDeps = (capabilities & RUNTIME_HINT_DEPS) !== 0;
+  const needsLogger = hasLog || hasFf || hasScope;
   /**
    * SpanContext implementation class.
    *
    * Constructor takes core values directly so arrow functions can close over them,
    * avoiding both temp object allocation and property lookups in hot paths.
    */
-  class SpanContextImpl {
-    // Core properties set via constructor
-    _buffer: SpanBuffer<Ctx['logSchema']>;
-    _schema: Ctx['logSchema'];
-    _spanLogger: SpanLoggerImpl<Ctx['logSchema']>;
-    _logBinding: LogBinding<Ctx['logSchema']> = logBinding;
 
-    // User-facing properties
-    tag: TagWriter<Ctx['logSchema']>;
-    log: SpanLogger<Ctx['logSchema']>;
-    ff!: FeatureFlagEvaluator<Ctx> & InferFeatureFlagsWithContext<Ctx>;
-    deps!: Record<string, unknown>;
+  class SpanContextImpl implements WriterState {
+    declare readonly _spanBuffer: SpanBuffer<Ctx['logSchema']>;
+    declare _buffer: AnySpanBuffer;
+    declare readonly _appendLogEntry: WriterState['_appendLogEntry'];
+    declare _schema: Ctx['logSchema'];
+    declare _spanLogger: SpanLoggerImpl<Ctx['logSchema']>;
+    declare _logBinding: LogBinding<Ctx['logSchema']>;
+    declare _physicalLayoutPlan: CallsitePlan<Ctx['logSchema'], Ctx>;
+
+    declare tag: TagWriter<Ctx['logSchema']>;
+    declare log: SpanLogger<Ctx['logSchema']>;
+    declare ff: FeatureFlagEvaluator<Ctx> & InferFeatureFlagsWithContext<Ctx>;
+    declare deps: Record<string, unknown>;
 
-    // Index signature for user context properties (env, requestId, etc.)
     [key: string]: unknown;
 
-    // Arrow functions that close over constructor args directly
-    setScope: (attributes: ScopeUpdate<Ctx['logSchema']> | null) => void;
-    ok: <V>(value: V) => Ok<V, Ctx['logSchema']>;
-    err: <E>(error: E) => Err<E, Ctx['logSchema']>;
-    span: SpanFn<Ctx>;
-    spanSync: SpanSyncFn<Ctx>;
+    declare setScope: (attributes: ScopeUpdate<Ctx['logSchema']> | null) => void;
+    declare ok: <V>(value: V) => Ok<V, Ctx['logSchema']>;
+    declare err: <E>(error: E) => Err<E, Ctx['logSchema']>;
+    declare span: SpanFn<Ctx>;
+    declare spanSync: SpanSyncFn<Ctx>;
 
     constructor(
       buffer: SpanBuffer<Ctx['logSchema']>,
       schema: Ctx['logSchema'],
-      spanLogger: SpanLoggerImpl<Ctx['logSchema']>,
-      tag: TagWriter<Ctx['logSchema']>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      contextSource?: Record<string, unknown>,
+      contextOverrides?: Record<string, unknown>,
+      deps?: Record<string, unknown>,
+      ffSource?: FlagEvaluator<Ctx> | (FeatureFlagEvaluator<Ctx> & InferFeatureFlagsWithContext<Ctx>),
     ) {
       //#region smoo/lmao!n/codegen-destructured-context
       // Destructured-context assembly (01g): every property an op destructures —
       // tag, log, scope (setScope), ok, err, span — is wired here as a closed-over
       // field/closure so `op(({ tag, log, span, ok, err }) => ...)` needs no ctx drilling.
+      this._spanBuffer = buffer;
       this._buffer = buffer;
+      this._appendLogEntry = callsitePlan.appendLogEntry;
       this._schema = schema;
-      this._spanLogger = spanLogger;
-      this.tag = tag;
-      this.log = spanLogger;
+      this._logBinding = logBinding;
+      this._physicalLayoutPlan = callsitePlan;
+      const spanLogger = callsitePlan.newSpanLogger?.(this);
+      const tag = callsitePlan.newTagWriter?.(this);
+      if (needsLogger) {
+        if (!spanLogger) throw new TypeError('SpanContext capability requires a logger');
+        this._spanLogger = spanLogger;
+      }
+      if (hasTag) {
+        if (!tag) throw new TypeError('SpanContext tag capability requires a tag writer');
+        this.tag = tag;
+      }
+      if (hasLog && spanLogger) this.log = spanLogger;
+      if (hasDeps) this.deps = deps ?? {};
+      if (hasFf && ffSource) this.ff = ffSource.forContext(this);
+      for (const key of canonicalUserContextKeys) {
+        let value = contextSource?.[key];
+        if (contextOverrides && Object.prototype.propertyIsEnumerable.call(contextOverrides, key)) {
+          const overrideValue = contextOverrides[key];
+          if (overrideValue !== undefined) value = overrideValue;
+        }
+        this[key] = value;
+      }
 
       // Regular functions close over constructor args directly - no property lookups
       // Using regular function (not arrow) allows destructuring while closing over args
-      this.setScope = (attributes: ScopeUpdate<Ctx['logSchema']> | null): void => {
-        spanLogger._setScope(attributes ?? {});
-      };
-
-      this.ok = <V>(value: V): Ok<V, Ctx['logSchema']> => new Ok<V, Ctx['logSchema']>(value, schema, buffer);
+      if (hasScope) {
+        if (!spanLogger) throw new TypeError('SpanContext scope capability requires a logger');
+        this.setScope = (attributes: ScopeUpdate<Ctx['logSchema']> | null): void => {
+          spanLogger._setScope(attributes ?? {});
+        };
+      }
 
-      this.err = <E>(error: E): Err<E, Ctx['logSchema']> => new Err<E, Ctx['logSchema']>(error, schema, buffer);
+      if (hasResult) {
+        this.ok = <V>(value: V): Ok<V, Ctx['logSchema']> => new Ok<V, Ctx['logSchema']>(value, this);
+        this.err = <E>(error: E): Err<E, Ctx['logSchema']> => new Err<E, Ctx['logSchema']>(error, this);
+      }
       //#endregion smoo/lmao!n/codegen-destructured-context
 
       //#region smoo/lmao!n/context-flow-span-promise
@@ -706,199 +887,167 @@ export function createSpanContextClass<Ctx extends OpContext>(
       // span uses regular function to access `arguments` (no ...rest spread allocation)
       // Closes over `self` for calling prototype methods
       // Named function for better stack traces
-      const self = this;
-      const span: SpanFn<Ctx> = function span(
-        nameOrLine: string | number,
-        _arg1?: unknown,
-        _arg2?: unknown,
-        _arg3?: unknown,
-        _arg4?: unknown,
-        _arg5?: unknown,
-        _arg6?: unknown,
-        _arg7?: unknown,
-        _arg8?: unknown,
-        _arg9?: unknown,
-        _arg10?: unknown,
-        _arg11?: unknown,
-      ): Promise<Result<unknown, unknown>> {
-        // Use arguments.length instead of ...rest to avoid array allocation
-        const len = arguments.length;
-
-        // Detect call pattern:
-        // - span(name, fn) - len=2, typeof arg0 === 'string'
-        // - span(line, name, fn) - len=3, typeof arg0 === 'number'
-        // - span(name, overrides, fn) - len=3, typeof arg0 === 'string', typeof arg1 === 'object'
-        // - span(line, name, overrides, fn) - len=4, typeof arg0 === 'number', typeof arg2 === 'object'
-        // Plus additional args for span arguments
-
-        const hasLine = typeof nameOrLine === 'number';
-        const spanLine = hasLine ? nameOrLine : 0;
-        const spanName = hasLine ? readStringArgument(arguments, 1, 'span name') : nameOrLine;
-
-        // Index where fn/op or overrides starts
-        const checkIdx = hasLine ? 2 : 1;
-        const maybeOverrides = arguments[checkIdx];
-
-        // Check if it's an overrides object (not Op, not function)
-        const hasOverrides =
-          maybeOverrides !== null &&
-          typeof maybeOverrides === 'object' &&
-          !(maybeOverrides instanceof Op) &&
-          typeof maybeOverrides !== 'function';
-
-        const fnIdx = checkIdx + (hasOverrides ? 1 : 0);
-        const target = resolveSpanTarget<Ctx>(arguments[fnIdx], self._buffer);
-
-        // Create child context - use _newCtx0 or _newCtx1 based on overrides
-        const childCtx = hasOverrides ? self._newCtx1(maybeOverrides) : self._newCtx0();
-
-        // Dispatch to monomorphic methods with all Op properties extracted
-        const argCount = len - fnIdx - 1;
-        switch (argCount) {
-          case 0:
-            return self.span0(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-            );
-          case 1:
-            return self.span1(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-            );
-          case 2:
-            return self.span2(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-            );
-          case 3:
-            return self.span3(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-            );
-          case 4:
-            return self.span4(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-            );
-          case 5:
-            return self.span5(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-            );
-          case 6:
-            return self.span6(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-              arguments[fnIdx + 6],
-            );
-          case 7:
-            return self.span7(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-              arguments[fnIdx + 6],
-              arguments[fnIdx + 7],
-            );
-          case 8:
-            return self.span8(
-              spanLine,
-              spanName,
-              childCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-              arguments[fnIdx + 6],
-              arguments[fnIdx + 7],
-              arguments[fnIdx + 8],
-            );
-          default:
-            throw new Error(`span() supports up to 8 arguments, got ${argCount}`);
-        }
-      };
-      this.span = span;
-
-      this.spanSync = function spanSync<S, E>(name: string, fn: (ctx: SpanContext<Ctx>) => Result<S, E>): Result<S, E> {
-        const childCtx = self._newCtx0();
-        return self.spanSync0(
-          0,
-          name,
-          childCtx,
-          getBufferConstructor(self._buffer),
-          undefined,
-          self._buffer._opMetadata,
-          fn,
-        );
-      };
+      if (hasSpan) {
+        const self = this;
+        const span: SpanFn<Ctx> = function span(
+          nameOrLine: string | number,
+          _arg1?: unknown,
+          _arg2?: unknown,
+          _arg3?: unknown,
+          _arg4?: unknown,
+          _arg5?: unknown,
+          _arg6?: unknown,
+          _arg7?: unknown,
+          _arg8?: unknown,
+          _arg9?: unknown,
+          _arg10?: unknown,
+          _arg11?: unknown,
+        ): Promise<Result<unknown, unknown>> {
+          // Use arguments.length instead of ...rest to avoid array allocation
+          const len = arguments.length;
+
+          // Detect call pattern:
+          // - span(name, fn) - len=2, typeof arg0 === 'string'
+          // - span(line, name, fn) - len=3, typeof arg0 === 'number'
+          // - span(name, overrides, fn) - len=3, typeof arg0 === 'string', typeof arg1 === 'object'
+          // - span(line, name, overrides, fn) - len=4, typeof arg0 === 'number', typeof arg2 === 'object'
+          // Plus additional args for span arguments
+
+          const hasLine = typeof nameOrLine === 'number';
+          const spanLine = hasLine ? nameOrLine : 0;
+          const spanName = hasLine ? readStringArgument(arguments, 1, 'span name') : nameOrLine;
+
+          // Index where fn/op or overrides starts
+          const checkIdx = hasLine ? 2 : 1;
+          const maybeOverrides = arguments[checkIdx];
+
+          // Check if it's an overrides object (not Op, not function)
+          const hasOverrides =
+            maybeOverrides !== null &&
+            typeof maybeOverrides === 'object' &&
+            !isOpLike(maybeOverrides) &&
+            typeof maybeOverrides !== 'function';
+
+          const fnIdx = checkIdx + (hasOverrides ? 1 : 0);
+          const target = resolveSpanTarget<Ctx>(
+            arguments[fnIdx],
+            self._physicalLayoutPlan,
+            self._spanBuffer._opMetadata,
+          );
+          const childCtx = asSpanContextInstance<Ctx>(
+            hasOverrides ? target.callsitePlan.newCtx1(self, maybeOverrides) : target.callsitePlan.newCtx0(self),
+          );
+
+          // Dispatch to monomorphic methods with all Op properties extracted
+          const argCount = len - fnIdx - 1;
+          switch (argCount) {
+            case 0:
+              return self.span0(spanLine, spanName, childCtx, target.callsitePlan, target.fn);
+            case 1:
+              return self.span1(spanLine, spanName, childCtx, target.callsitePlan, target.fn, arguments[fnIdx + 1]);
+            case 2:
+              return self.span2(
+                spanLine,
+                spanName,
+                childCtx,
+                target.callsitePlan,
+                target.fn,
+                arguments[fnIdx + 1],
+                arguments[fnIdx + 2],
+              );
+            case 3:
+              return self.span3(
+                spanLine,
+                spanName,
+                childCtx,
+                target.callsitePlan,
+                target.fn,
+                arguments[fnIdx + 1],
+                arguments[fnIdx + 2],
+                arguments[fnIdx + 3],
+              );
+            case 4:
+              return self.span4(
+                spanLine,
+                spanName,
+                childCtx,
+                target.callsitePlan,
+                target.fn,
+                arguments[fnIdx + 1],
+                arguments[fnIdx + 2],
+                arguments[fnIdx + 3],
+                arguments[fnIdx + 4],
+              );
+            case 5:
+              return self.span5(
+                spanLine,
+                spanName,
+                childCtx,
+                target.callsitePlan,
+                target.fn,
+                arguments[fnIdx + 1],
+                arguments[fnIdx + 2],
+                arguments[fnIdx + 3],
+                arguments[fnIdx + 4],
+                arguments[fnIdx + 5],
+              );
+            case 6:
+              return self.span6(
+                spanLine,
+                spanName,
+                childCtx,
+                target.callsitePlan,
+                target.fn,
+                arguments[fnIdx + 1],
+                arguments[fnIdx + 2],
+                arguments[fnIdx + 3],
+                arguments[fnIdx + 4],
+                arguments[fnIdx + 5],
+                arguments[fnIdx + 6],
+              );
+            case 7:
+              return self.span7(
+                spanLine,
+                spanName,
+                childCtx,
+                target.callsitePlan,
+                target.fn,
+                arguments[fnIdx + 1],
+                arguments[fnIdx + 2],
+                arguments[fnIdx + 3],
+                arguments[fnIdx + 4],
+                arguments[fnIdx + 5],
+                arguments[fnIdx + 6],
+                arguments[fnIdx + 7],
+              );
+            case 8:
+              return self.span8(
+                spanLine,
+                spanName,
+                childCtx,
+                target.callsitePlan,
+                target.fn,
+                arguments[fnIdx + 1],
+                arguments[fnIdx + 2],
+                arguments[fnIdx + 3],
+                arguments[fnIdx + 4],
+                arguments[fnIdx + 5],
+                arguments[fnIdx + 6],
+                arguments[fnIdx + 7],
+                arguments[fnIdx + 8],
+              );
+            default:
+              throw new Error(`span() supports up to 8 arguments, got ${argCount}`);
+          }
+        };
+        this.span = span;
+
+        this.spanSync = function spanSync<S, E>(name: string, op: Op<Ctx, [], S, E>): Result<S, E> {
+          const callsitePlan = op.callsitePlan;
+          const childCtx = asSpanContextInstance<Ctx>(callsitePlan.newCtx0(self));
+          return self.spanSync0(0, name, childCtx, callsitePlan, op.fn);
+        };
+      }
       //#endregion smoo/lmao!n/context-flow-span-promise
     }
 
@@ -911,36 +1060,36 @@ export function createSpanContextClass<Ctx extends OpContext>(
     }
 
     get module(): import('./opContext/opTypes.js').OpMetadata {
-      return this._buffer._opMetadata;
+      return this._spanBuffer._opMetadata;
     }
 
     get callee_package(): string {
-      return this._buffer._opMetadata.package_name;
+      return this._spanBuffer._opMetadata.package_name;
     }
 
     get callee_file(): string {
-      return this._buffer._opMetadata.package_file;
+      return this._spanBuffer._opMetadata.package_file;
     }
 
     get callee_line(): number {
       // Access the line_values array directly to read line number at row 0
       // line_values is a Float64Array per the system schema (LazyNumberSchema)
-      return this._buffer.line_values[0];
+      return this._spanBuffer.line_values[0];
     }
 
     get callee_git_sha(): string {
-      return this._buffer._opMetadata.git_sha;
+      return this._spanBuffer._opMetadata.git_sha;
     }
 
     get buffer(): SpanBuffer<Ctx['logSchema']> {
-      return this._buffer;
+      return this._spanBuffer;
     }
 
     //#region smoo/lmao!n/scope-attributes.read
     // 01i read-only scope view: the immutable _scopeValues snapshot (setScope is wired in the
     // destructured-context region; the immutable merge is _setScope in spanLoggerGenerator).
     get scope(): Readonly<Partial<InferSchema<Ctx['logSchema']>>> {
-      return this._buffer._scopeValues;
+      return this._spanBuffer._scopeValues;
     }
     //#endregion smoo/lmao!n/scope-attributes.read
 
@@ -948,6 +1097,15 @@ export function createSpanContextClass<Ctx extends OpContext>(
     // Internal methods (on prototype)
     // =========================================================================
 
+    _appendWriterEntry(entryType: number): number {
+      if (this._buffer._writeIndex >= this._buffer._capacity) {
+        this._buffer = this._buffer.getOrCreateOverflow();
+        this._spanLogger._prefillScopedAttributesOn(this._buffer);
+      }
+      const traceRoot = this._buffer._traceRoot;
+      return this._appendLogEntry(traceRoot, this._buffer, entryType);
+    }
+
     /**
      * Create a new child context with prototype chain inheritance.
      * Called by transformer for spans without overrides.
@@ -955,7 +1113,7 @@ export function createSpanContextClass<Ctx extends OpContext>(
      * Transformer emits: ctx.span0(line, name, ctx._newCtx0(), fn)
      */
     _newCtx0(): SpanContextInstance<Ctx> {
-      return createInheritedContext(this);
+      return asSpanContextInstance<Ctx>(this._physicalLayoutPlan.newCtx0(this));
     }
 
     /**
@@ -965,7 +1123,7 @@ export function createSpanContextClass<Ctx extends OpContext>(
      * Transformer emits: ctx.span0(line, name, ctx._newCtx1({ requestId }), fn)
      */
     _newCtx1(overrides: object): SpanContextInstance<Ctx> {
-      return createInheritedContextWithOverrides(this, overrides);
+      return asSpanContextInstance<Ctx>(this._physicalLayoutPlan.newCtx1(this, overrides));
     }
 
     /**
@@ -979,273 +1137,49 @@ export function createSpanContextClass<Ctx extends OpContext>(
      * @param line - Source line number (0 if not provided by transformer)
      * @param name - Child span name
      * @param SpanBufferClass - Buffer class to use (Op's class or parent's class for plain functions)
-     * @param remappedViewClass - Optional view class for prefixed ops (wraps buffer for Arrow conversion)
+     * @param remapDescriptor - Optional immutable cold-path output mapping
      * @param opMetadata - Metadata for the executing op (Op's metadata or parent's for plain functions)
      */
     //#region smoo/lmao!n/context-flow-child-span
     // 01c "Child Span Creation via span()" / "How span() Works" and 01e "Op's Responsibility:
-    // Buffer Creation and Registration": _spanPre is where the child SpanBuffer is created
-    // (via the buffer strategy, using the Op's SpanBufferClass for cross-library schema),
-    // wrapped in a RemappedBufferView when the dep is prefixed/mapped, registered in the
-    // parent's _children, and span-start (row 0) is written with the caller's line number.
+    // _spanPre creates the child through the planned schema/capacity, attaches the immutable
+    // cold-path remap descriptor to the raw buffer, registers it, and writes row 0.
     _spanPre(
       childCtx: SpanContextInstance<Ctx>,
       line: number,
-      name: string,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
+      name: string | number,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       opMetadata: OpMetadata,
     ): SpanContextInstance<Ctx> {
-      // Get Op's schema for cross-library calls (child may have different schema than parent)
-      const childSchema = SpanBufferClass.schema;
-
-      // Use buffer strategy for child span creation (supports both JS and WASM buffers)
-      // Pass schema for cross-library calls where child has different schema than parent
-      const createdBuffer = this._buffer._traceRoot.tracer.bufferStrategy.createChildSpanBuffer(
-        this._buffer, // parentBuffer
-        this._buffer._opMetadata, // callsiteMetadata - WHO called span() (for row 0)
-        opMetadata, // opMetadata - WHICH op is executing (for rows 1+)
-        undefined, // capacity - use default
-        childSchema, // schema - Op's schema for correct tag methods
+      const childSchema = callsitePlan.schema;
+      const createdBuffer = this._spanBuffer._traceRoot.tracer.bufferStrategy.createChildSpanBuffer(
+        this._spanBuffer,
+        this._spanBuffer._opMetadata,
+        opMetadata,
+        callsitePlan.capacityTier,
+        childSchema,
+        callsitePlan.SpanBufferClass,
       );
-      if (!isSpanBufferForSchema(createdBuffer, childSchema)) {
-        throw new TypeError('Child span buffer does not match the requested schema');
-      }
       const childBuffer = createdBuffer;
-
-      // Why wrap buffer: RemappedBufferView translates prefixed column names during Arrow conversion
-      // Parent sees remapped names, child sees unprefixed names (transparent to child)
-      const bufferOrView = remappedViewClass ? new remappedViewClass(childBuffer) : childBuffer;
-
-      // Why push wrapped buffer: Parent's _children see remapped names for Arrow conversion
-      this._buffer._children.push(bufferOrView);
-
-      // Write span-start for child span (row 0) and pre-initialize span-end (row 1)
-      writeSpanStart(childBuffer, name);
-
-      // Write line number to row 0 (line() takes pos and value)
+      childBuffer._remapDescriptor = callsitePlan.remapDescriptor ?? undefined;
+      callsitePlan.appenders.writeSpanStart(childBuffer, name);
       childBuffer.line(0, line);
-      const childLogger = createSpanLogger(childSchema, childBuffer);
-      const childTagAPI = createTagWriter(childSchema, childBuffer);
-
-      // Cast to impl for property assignment
-      const ctx = childCtx;
-
-      // ═══════════════════════════════════════════════════════════════════
-      // PROPERTY ASSIGNMENT ORDER: HOT → COLD (V8 in-object slots optimization)
-      // First ~10-12 properties get fast in-object slots per spec
-      // ═══════════════════════════════════════════════════════════════════
-
-      // SLOT 1-4: HOTTEST - accessed on every span operation
-      ctx._buffer = childBuffer;
-      ctx._spanLogger = childLogger;
-      ctx.tag = childTagAPI;
-      ctx.log = childLogger;
-
-      // SLOT 5-7: HOT - reserved keys copied from parent for O(1) access
-      ctx.deps = this.deps;
-      // Create child-bound FF evaluator so flag access logs to child buffer
-      // If no evaluator (ff is EMPTY_SCOPE), just copy the reference
-      ctx.ff = this.ff.forContext ? this.ff.forContext(ctx) : this.ff;
-      // Note: user-defined extras (env, requestId, etc.) inherited via prototype chain
-
-      // SLOT 8-11: WARM - function properties (created per-context for destructuring)
-      // Regular functions close over local variables directly - no property lookups
-      const childSpan: SpanFn<Ctx> = function span(
-        nameOrLine: string | number,
-        _arg1?: unknown,
-        _arg2?: unknown,
-        _arg3?: unknown,
-        _arg4?: unknown,
-        _arg5?: unknown,
-        _arg6?: unknown,
-        _arg7?: unknown,
-        _arg8?: unknown,
-        _arg9?: unknown,
-        _arg10?: unknown,
-        _arg11?: unknown,
-      ): Promise<Result<unknown, unknown>> {
-        const len = arguments.length;
-        const hasLine = typeof nameOrLine === 'number';
-        const spanLine = hasLine ? nameOrLine : 0;
-        const spanName = hasLine ? readStringArgument(arguments, 1, 'span name') : nameOrLine;
-        const checkIdx = hasLine ? 2 : 1;
-        const maybeOverrides = arguments[checkIdx];
-        const hasOverrides =
-          maybeOverrides !== null &&
-          typeof maybeOverrides === 'object' &&
-          !(maybeOverrides instanceof Op) &&
-          typeof maybeOverrides !== 'function';
-        const fnIdx = checkIdx + (hasOverrides ? 1 : 0);
-        const target = resolveSpanTarget<Ctx>(arguments[fnIdx], childBuffer);
-
-        // Create child context - use _newCtx0 or _newCtx1 based on overrides
-        const newChildCtx = hasOverrides ? ctx._newCtx1(maybeOverrides) : ctx._newCtx0();
-        const argCount = len - fnIdx - 1;
-        switch (argCount) {
-          case 0:
-            return ctx.span0(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-            );
-          case 1:
-            return ctx.span1(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-            );
-          case 2:
-            return ctx.span2(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-            );
-          case 3:
-            return ctx.span3(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-            );
-          case 4:
-            return ctx.span4(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-            );
-          case 5:
-            return ctx.span5(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-            );
-          case 6:
-            return ctx.span6(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-              arguments[fnIdx + 6],
-            );
-          case 7:
-            return ctx.span7(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-              arguments[fnIdx + 6],
-              arguments[fnIdx + 7],
-            );
-          case 8:
-            return ctx.span8(
-              spanLine,
-              spanName,
-              newChildCtx,
-              target.SpanBufferClass,
-              target.remappedViewClass,
-              target.opMetadata,
-              target.fn,
-              arguments[fnIdx + 1],
-              arguments[fnIdx + 2],
-              arguments[fnIdx + 3],
-              arguments[fnIdx + 4],
-              arguments[fnIdx + 5],
-              arguments[fnIdx + 6],
-              arguments[fnIdx + 7],
-              arguments[fnIdx + 8],
-            );
-          default:
-            throw new Error(`span() supports up to 8 arguments, got ${argCount}`);
-        }
-      };
-      ctx.span = childSpan;
-
-      ctx.spanSync = function spanSync<S, E>(
-        name: string,
-        fn: (syncCtx: SpanContext<Ctx>) => Result<S, E>,
-      ): Result<S, E> {
-        const newChildCtx = ctx._newCtx0();
-        return ctx.spanSync0(
-          0,
-          name,
-          newChildCtx,
-          getBufferConstructor(childBuffer),
-          undefined,
-          childBuffer._opMetadata,
-          fn,
-        );
-      };
-
-      ctx.ok = function ok<V>(value: V): Ok<V, Ctx['logSchema']> {
-        return new Ok<V, Ctx['logSchema']>(value, childSchema, childBuffer);
-      };
-      ctx.err = function err<E>(error: E): Err<E, Ctx['logSchema']> {
-        return new Err<E, Ctx['logSchema']>(error, childSchema, childBuffer);
-      };
-      ctx.setScope = function setScope(attributes: ScopeUpdate<Ctx['logSchema']> | null): void {
-        childLogger._setScope(attributes ?? {});
-      };
-
-      // SLOT 12+: COLD - internal/rarely accessed
-      ctx._schema = childSchema;
-      ctx._logBinding = logBinding;
-
-      return ctx;
+
+      const childFfSource = Object.hasOwn(this, 'ff')
+        ? this.ff
+        : this._spanBuffer._traceRoot.tracer.getFlagEvaluatorForContext();
+      if (!isFlagEvaluatorForContext<Ctx>(childFfSource)) {
+        throw new TypeError('Span context requires a context evaluator');
+      }
+      return new callsitePlan.SpanContextClass(
+        childBuffer,
+        childSchema,
+        callsitePlan,
+        childCtx,
+        undefined,
+        this.deps,
+        childFfSource,
+      );
     }
     //#endregion smoo/lmao!n/context-flow-child-span
 
@@ -1255,8 +1189,7 @@ export function createSpanContextClass<Ctx extends OpContext>(
      * Called in catch blocks of span methods.
      */
     _spanException(childBuffer: SpanBuffer<Ctx['logSchema']>, error: unknown): void {
-      // Write entry_type and timestamp via TraceRoot (platform-specific)
-      childBuffer._traceRoot.writeSpanEnd(childBuffer, ENTRY_TYPE_SPAN_EXCEPTION);
+      writeSpanEndEntry(childBuffer, ENTRY_TYPE_SPAN_EXCEPTION);
       const errorMessage = error instanceof Error ? error.message : String(error);
       const errorStack = error instanceof Error ? error.stack : undefined;
       childBuffer.message(1, errorMessage);
@@ -1266,27 +1199,600 @@ export function createSpanContextClass<Ctx extends OpContext>(
     }
     //#endregion smoo/lmao!n/lmao-entry-span-lifecycle-entry-types.exception
 
+    private _spanAutoPre<Args extends unknown[], S, E>(
+      line: number,
+      name: string,
+      op: Op<Ctx, Args, S, E>,
+    ): SpanContextInstance<Ctx> {
+      const child = asSpanContextInstance<Ctx>(op.callsitePlan.newCtx0(this));
+      return this._spanPre(child, line, name, op.callsitePlan, op.metadata);
+    }
+
+    spanAuto0<S, E>(line: number, name: string, op: Op<Ctx, [], S, E>): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync0(ctx, buffer, op, result);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync0<S, E>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto1<S, E, A1>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1], S, E>,
+      a1: A1,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync1(ctx, buffer, op, result, a1);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync1<S, E, A1>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto2<S, E, A1, A2>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1, A2], S, E>,
+      a1: A1,
+      a2: A2,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1, a2);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync2(ctx, buffer, op, result, a1, a2);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync2<S, E, A1, A2>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1, A2], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1, a2);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto3<S, E, A1, A2, A3>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1, A2, A3], S, E>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1, a2, a3);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync3(ctx, buffer, op, result, a1, a2, a3);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync3<S, E, A1, A2, A3>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1, A2, A3], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1, a2, a3);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto4<S, E, A1, A2, A3, A4>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1, A2, A3, A4], S, E>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1, a2, a3, a4);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync4(ctx, buffer, op, result, a1, a2, a3, a4);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync4<S, E, A1, A2, A3, A4>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1, A2, A3, A4], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1, a2, a3, a4);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto5<S, E, A1, A2, A3, A4, A5>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1, A2, A3, A4, A5], S, E>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1, a2, a3, a4, a5);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync5(ctx, buffer, op, result, a1, a2, a3, a4, a5);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync5<S, E, A1, A2, A3, A4, A5>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1, A2, A3, A4, A5], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1, a2, a3, a4, a5);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto6<S, E, A1, A2, A3, A4, A5, A6>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1, A2, A3, A4, A5, A6], S, E>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+      a6: A6,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1, a2, a3, a4, a5, a6);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync6(ctx, buffer, op, result, a1, a2, a3, a4, a5, a6);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync6<S, E, A1, A2, A3, A4, A5, A6>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1, A2, A3, A4, A5, A6], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+      a6: A6,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1, a2, a3, a4, a5, a6);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto7<S, E, A1, A2, A3, A4, A5, A6, A7>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1, A2, A3, A4, A5, A6, A7], S, E>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+      a6: A6,
+      a7: A7,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1, a2, a3, a4, a5, a6, a7);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync7(ctx, buffer, op, result, a1, a2, a3, a4, a5, a6, a7);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync7<S, E, A1, A2, A3, A4, A5, A6, A7>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1, A2, A3, A4, A5, A6, A7], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+      a6: A6,
+      a7: A7,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1, a2, a3, a4, a5, a6, a7);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
+    spanAuto8<S, E, A1, A2, A3, A4, A5, A6, A7, A8>(
+      line: number,
+      name: string,
+      op: Op<Ctx, [A1, A2, A3, A4, A5, A6, A7, A8], S, E>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+      a6: A6,
+      a7: A7,
+      a8: A8,
+    ): Result<S, E> | Promise<Result<S, E>> {
+      const ctx = this._spanAutoPre(line, name, op);
+      const buffer = ctx._spanBuffer;
+      buffer._traceRoot.tracer.onSpanStart(buffer);
+      let isAsync = false;
+      try {
+        const result = op.fn(ctx, a1, a2, a3, a4, a5, a6, a7, a8);
+        if (!isSynchronousResult(result) || getRetryableError(result, 1) !== undefined) {
+          isAsync = true;
+          return this._spanAutoAsync8(ctx, buffer, op, result, a1, a2, a3, a4, a5, a6, a7, a8);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        if (!isAsync) {
+          buffer._traceRoot.tracer.onSpanEnd(buffer);
+        }
+      }
+    }
+
+    private async _spanAutoAsync8<S, E, A1, A2, A3, A4, A5, A6, A7, A8>(
+      ctx: SpanContextInstance<Ctx>,
+      buffer: SpanBuffer<Ctx['logSchema']>,
+      op: Op<Ctx, [A1, A2, A3, A4, A5, A6, A7, A8], S, E>,
+      first: Result<S, E> | PromiseLike<Result<S, E>>,
+      a1: A1,
+      a2: A2,
+      a3: A3,
+      a4: A4,
+      a5: A5,
+      a6: A6,
+      a7: A7,
+      a8: A8,
+    ): Promise<Result<S, E>> {
+      try {
+        let attempt = 1;
+        let result = await first;
+        while (true) {
+          const retryError = getRetryableError(result, attempt);
+          if (!retryError) break;
+          const delay = calculateDelay(retryError.policy, attempt);
+          writeRetryEntry(buffer, attempt, retryError, delay);
+          await sleep(delay);
+          attempt++;
+          result = await op.fn(ctx, a1, a2, a3, a4, a5, a6, a7, a8);
+        }
+        writeSpanEnd(buffer, result);
+        return result;
+      } catch (error) {
+        this._spanException(buffer, error);
+        throw error;
+      } finally {
+        buffer._traceRoot.tracer.onSpanEnd(buffer);
+      }
+    }
+
     // =========================================================================
     // Monomorphic span methods (for transformer output)
-    // Transformer emits: ctx.span0(line, name, ctx, fn) or
-    //                    ctx.span0(line, name, Object.assign(Object.create(ctx), overrides), fn)
-    // childCtx inherits from parent via prototype chain, may have user overrides as own properties
+    // Transformer emits: ctx.span0(line, name, plan.newCtx0(ctx), plan, fn)
+    // The frozen plan supplies the exact context source factory for each callsite.
+    // User overrides are materialized by plan.newCtx1 without prototype allocation.
     // =========================================================================
 
     spanSync0<S, E>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
-      fn: (ctx: SpanContext<Ctx>) => Result<S, E>,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
+      fn: (ctx: SpanContext<Ctx>) => Result<S, E> | Promise<Result<S, E>>,
     ): Result<S, E> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         const result = fn(ctx);
+        if (!isSynchronousResult(result)) {
+          throw new TypeError('spanSync operation returned a Promise');
+        }
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1299,19 +1805,17 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span0<S, E>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (ctx: SpanContext<Ctx>) => Result<S, E> | Promise<Result<S, E>>,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx));
+        const result = await executeWithRetry0(buffer, fn, ctx);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1324,20 +1828,18 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span1<S, E, A1>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (ctx: SpanContext<Ctx>, a1: A1) => Result<S, E> | Promise<Result<S, E>>,
       a1: A1,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1));
+        const result = await executeWithRetry1(buffer, fn, ctx, a1);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1350,21 +1852,19 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span2<S, E, A1, A2>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2) => Result<S, E> | Promise<Result<S, E>>,
       a1: A1,
       a2: A2,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1, a2));
+        const result = await executeWithRetry2(buffer, fn, ctx, a1, a2);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1377,22 +1877,20 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span3<S, E, A1, A2, A3>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3) => Result<S, E> | Promise<Result<S, E>>,
       a1: A1,
       a2: A2,
       a3: A3,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1, a2, a3));
+        const result = await executeWithRetry3(buffer, fn, ctx, a1, a2, a3);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1405,23 +1903,21 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span4<S, E, A1, A2, A3, A4>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4) => Result<S, E> | Promise<Result<S, E>>,
       a1: A1,
       a2: A2,
       a3: A3,
       a4: A4,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1, a2, a3, a4));
+        const result = await executeWithRetry4(buffer, fn, ctx, a1, a2, a3, a4);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1434,11 +1930,9 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span5<S, E, A1, A2, A3, A4, A5>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (ctx: SpanContext<Ctx>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => Result<S, E> | Promise<Result<S, E>>,
       a1: A1,
       a2: A2,
@@ -1446,12 +1940,12 @@ export function createSpanContextClass<Ctx extends OpContext>(
       a4: A4,
       a5: A5,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1, a2, a3, a4, a5));
+        const result = await executeWithRetry5(buffer, fn, ctx, a1, a2, a3, a4, a5);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1464,11 +1958,9 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span6<S, E, A1, A2, A3, A4, A5, A6>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (
         ctx: SpanContext<Ctx>,
         a1: A1,
@@ -1485,12 +1977,12 @@ export function createSpanContextClass<Ctx extends OpContext>(
       a5: A5,
       a6: A6,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1, a2, a3, a4, a5, a6));
+        const result = await executeWithRetry6(buffer, fn, ctx, a1, a2, a3, a4, a5, a6);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1503,11 +1995,9 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span7<S, E, A1, A2, A3, A4, A5, A6, A7>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (
         ctx: SpanContext<Ctx>,
         a1: A1,
@@ -1526,12 +2016,12 @@ export function createSpanContextClass<Ctx extends OpContext>(
       a6: A6,
       a7: A7,
     ): Promise<Result<S, E>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1, a2, a3, a4, a5, a6, a7));
+        const result = await executeWithRetry7(buffer, fn, ctx, a1, a2, a3, a4, a5, a6, a7);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1544,11 +2034,9 @@ export function createSpanContextClass<Ctx extends OpContext>(
 
     async span8<S, E, A1, A2, A3, A4, A5, A6, A7, A8>(
       line: number,
-      name: string,
+      name: string | number,
       childCtx: SpanContextInstance<Ctx>,
-      SpanBufferClass: SpanBufferConstructor<Ctx['logSchema']>,
-      remappedViewClass: RemappedViewConstructor | undefined,
-      opMetadata: OpMetadata,
+      callsitePlan: CallsitePlan<Ctx['logSchema'], Ctx>,
       fn: (
         ctx: SpanContext<Ctx>,
         a1: A1,
@@ -1569,12 +2057,12 @@ export function createSpanContextClass<Ctx extends OpContext>(
       a7: A7,
       a8: A8,
     ): Promise<Result<S, E, Ctx['logSchema']>> {
-      const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-      const buffer = ctx._buffer;
+      const ctx = this._spanPre(childCtx, line, name, callsitePlan, callsitePlan.metadata);
+      const buffer = ctx._spanBuffer;
       buffer._traceRoot.tracer.onSpanStart(buffer);
       try {
         // Execute with retry loop - TransientError triggers retry, BlockedError returns immediately
-        const result = await executeWithRetry(buffer, () => fn(ctx, a1, a2, a3, a4, a5, a6, a7, a8));
+        const result = await executeWithRetry8(buffer, fn, ctx, a1, a2, a3, a4, a5, a6, a7, a8);
         writeSpanEnd(buffer, result);
         return result;
       } catch (error) {
@@ -1587,6 +2075,7 @@ export function createSpanContextClass<Ctx extends OpContext>(
   }
 
   const SpanContextCtor: SpanContextClass<Ctx> = SpanContextImpl;
+  cache.set(cacheKey, SpanContextCtor);
   return SpanContextCtor;
 }