@smoothbricks/lmao 0.2.2 → 0.2.3

package/dist/lib/spanContext.js

@@ -1,10 +1,8 @@
 /* biome-ignore-all lint/complexity/noArguments: hot-path overload dispatch avoids rest-arg allocations */
-import { createTagWriter } from './codegen/fixedPositionWriterGenerator.js';
 import { createSpanLogger as createSpanLoggerFromGenerator, } from './codegen/spanLoggerGenerator.js';
-import { Blocked } from './errors/Blocked.js';
 import { TransientError } from './errors/Transient.js';
-import { Op } from './op.js';
 import { Err, hasErrorCode, Ok } from './result.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 { ENTRY_TYPE_SPAN_ERR, ENTRY_TYPE_SPAN_EXCEPTION, ENTRY_TYPE_SPAN_OK, ENTRY_TYPE_SPAN_RETRY, } from './schema/systemSchema.js';
 // Note: TraceRoot.writeSpanStart() is used instead of direct timestamp writes.
 // The platform-specific TraceRoot (traceRoot.es.ts or traceRoot.node.ts) handles
@@ -17,8 +15,15 @@ import { ENTRY_TYPE_SPAN_ERR, ENTRY_TYPE_SPAN_EXCEPTION, ENTRY_TYPE_SPAN_OK, ENT
  * Used for type guards and prototype chain detection
  */
 export const SPAN_CONTEXT_MARKER = Symbol.for('lmao.SpanContext');
+function isOpLike(value) {
+    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(value) {
-    return value instanceof Op;
+    return isOpLike(value);
 }
 // WHY: resolveSpanTarget() accepts either an Op instance or a raw span
 // function. TypeScript needs an explicit predicate here to preserve the call
@@ -26,43 +31,19 @@ function isOpInstance(value) {
 function isSpanDispatchFn(value) {
     return typeof value === 'function';
 }
-function isSpanBufferConstructorForSchema(value, schema) {
-    return (typeof value === 'function' &&
-        Reflect.get(value, 'schema') === schema &&
-        typeof Reflect.get(value, 'stats') === 'object');
-}
-function getBufferConstructor(buffer) {
-    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(buffer, schema) {
-    return (typeof buffer === 'object' &&
-        buffer !== null &&
-        Reflect.get(buffer, '_logSchema') === schema &&
-        isSpanBufferConstructorForSchema(Reflect.get(buffer, 'constructor'), schema));
-}
 function isSpanContextInstance(value) {
     return (isSpanContext(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(parent) {
-    const child = Object.create(parent);
-    if (!isSpanContextInstance(child)) {
-        throw new TypeError('Failed to create child span context');
+function asSpanContextInstance(value) {
+    if (!isSpanContextInstance(value)) {
+        throw new TypeError('Callsite plan created an invalid child span context');
     }
-    return child;
-}
-function createInheritedContextWithOverrides(parent, overrides) {
-    const child = Object.assign(Object.create(parent), overrides);
-    if (!isSpanContextInstance(child)) {
-        throw new TypeError('Failed to create overridden child span context');
-    }
-    return child;
+    return value;
 }
 function readStringArgument(args, index, label) {
     const value = args[index];
@@ -71,11 +52,10 @@ function readStringArgument(args, index, label) {
     }
     return value;
 }
-function resolveSpanTarget(value, fallbackBuffer) {
+function resolveSpanTarget(value, fallbackPlan, fallbackMetadata) {
     if (isOpInstance(value)) {
         return {
-            SpanBufferClass: value.SpanBufferClass,
-            remappedViewClass: value.remappedViewClass,
+            callsitePlan: value.callsitePlan,
             opMetadata: value.metadata,
             fn: value.fn,
         };
@@ -84,12 +64,19 @@ function resolveSpanTarget(value, fallbackBuffer) {
         throw new TypeError('span() expects an Op or function');
     }
     return {
-        SpanBufferClass: getBufferConstructor(fallbackBuffer),
-        remappedViewClass: undefined,
-        opMetadata: fallbackBuffer._opMetadata,
+        callsitePlan: fallbackPlan,
+        opMetadata: fallbackMetadata,
         fn: value,
     };
 }
+function isSynchronousResult(value) {
+    return value instanceof Ok || value instanceof Err;
+}
+function getRetryableError(result, attempt) {
+    if (!(result instanceof Err) || !(result.error instanceof TransientError))
+        return undefined;
+    return attempt < result.error.policy.maxAttempts ? result.error : undefined;
+}
 // =============================================================================
 // Helper Functions
 // =============================================================================
@@ -109,21 +96,12 @@ function resolveSpanTarget(value, fallbackBuffer) {
  */
 export function writeSpanStart(buffer, spanName) {
     // 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(schema, buffer) {
-    return createSpanLoggerFromGenerator(schema, buffer);
+/** Create a SpanLogger bound to an existing SpanContext writer state. */
+export function createSpanLogger(schema, state) {
+    return createSpanLoggerFromGenerator(schema, state);
 }
 //#region smoo/lmao!n/op-retry.delay
 /**
@@ -175,9 +153,9 @@ function calculateDelay(policy, attempt) {
 function writeRetryEntry(buffer, attempt, error, delayMs) {
     // 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';
     buffer.message(index, `retry:op:${opName}`);
@@ -200,54 +178,130 @@ function writeRetryEntry(buffer, attempt, error, delayMs) {
 function sleep(ms) {
     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(buffer, fn) {
+async function executeWithRetry0(buffer, fn, ctx) {
     let attempt = 0;
     while (true) {
         attempt++;
-        // Execute the function
-        const result = await fn();
-        // Success - return immediately
-        if (result instanceof Ok) {
+        const result = await fn(ctx);
+        if (!(result instanceof Err) || !(result.error instanceof TransientError))
             return result;
-        }
-        // Error result - check error type for retry behavior
-        const error = result.error;
-        // BlockedError - return immediately, no retry
-        if (error instanceof Blocked) {
+        if (attempt >= result.error.policy.maxAttempts)
             return result;
-        }
-        // TransientError - check if we should retry
-        if (error instanceof TransientError) {
-            const { policy } = error;
-            // Check attempt limit (maxAttempts includes initial attempt)
-            if (attempt >= policy.maxAttempts) {
-                // Exhausted - return final error
-                return result;
-            }
-            // Calculate delay based on policy and attempt number
-            const delay = calculateDelay(policy, attempt);
-            // Write span-retry entry to buffer for observability
-            writeRetryEntry(buffer, attempt, error, delay);
-            // Wait before retry
-            await sleep(delay);
-            continue;
-        }
-        // Non-transient error - return immediately
-        return result;
+        const delay = calculateDelay(result.error.policy, attempt);
+        writeRetryEntry(buffer, attempt, result.error, delay);
+        await sleep(delay);
+    }
+}
+async function executeWithRetry1(buffer, fn, ctx, a1) {
+    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);
+    }
+}
+async function executeWithRetry2(buffer, fn, ctx, a1, a2) {
+    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);
+    }
+}
+async function executeWithRetry3(buffer, fn, ctx, a1, a2, a3) {
+    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);
+    }
+}
+async function executeWithRetry4(buffer, fn, ctx, a1, a2, a3, a4) {
+    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);
+    }
+}
+async function executeWithRetry5(buffer, fn, ctx, a1, a2, a3, a4, a5) {
+    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);
+    }
+}
+async function executeWithRetry6(buffer, fn, ctx, a1, a2, a3, a4, a5, a6) {
+    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);
+    }
+}
+async function executeWithRetry7(buffer, fn, ctx, a1, a2, a3, a4, a5, a6, a7) {
+    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);
+    }
+}
+async function executeWithRetry8(buffer, fn, ctx, a1, a2, a3, a4, a5, a6, a7, a8) {
+    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
@@ -264,13 +318,18 @@ async function executeWithRetry(buffer, fn) {
  * @param buffer - SpanBuffer to write to
  * @param result - The result returned by the span function
  */
+function writeSpanEndEntry(buffer, entryType) {
+    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(buffer, result) {
-    // 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);
@@ -281,6 +340,19 @@ export function writeSpanEnd(buffer, result) {
 // =============================================================================
 // SpanContext Class Factory
 // =============================================================================
+const spanContextClassCaches = new WeakMap();
+function isSpanContextClass(value) {
+    return typeof value === 'function';
+}
+export function isPhysicalLayoutPlanForContext(value, schema) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Reflect.get(value, 'schema') === schema &&
+        isSpanContextClass(Reflect.get(value, 'SpanContextClass')));
+}
+function isFlagEvaluatorForContext(value) {
+    return typeof value === 'object' && value !== null && typeof Reflect.get(value, 'forContext') === 'function';
+}
 /**
  * Create a SpanContext class for the given schema and logBinding.
  *
@@ -288,14 +360,33 @@ export function writeSpanEnd(buffer, result) {
  * - 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
  * @returns Class constructor for SpanContext instances
  */
-export function createSpanContextClass(_schemaOnly, logBinding) {
+export function createSpanContextClass(_schemaOnly, logBinding, capabilities = RUNTIME_HINT_FULL_CAPABILITIES, userContextKeys = []) {
+    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(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.
      *
@@ -303,39 +394,57 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
      * avoiding both temp object allocation and property lookups in hot paths.
      */
     class SpanContextImpl {
-        // Core properties set via constructor
-        _buffer;
-        _schema;
-        _spanLogger;
-        _logBinding = logBinding;
-        // User-facing properties
-        tag;
-        log;
-        ff;
-        deps;
-        // Arrow functions that close over constructor args directly
-        setScope;
-        ok;
-        err;
-        span;
-        spanSync;
-        constructor(buffer, schema, spanLogger, tag) {
+        constructor(buffer, schema, callsitePlan, contextSource, contextOverrides, deps, ffSource) {
             //#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) => {
-                spanLogger._setScope(attributes ?? {});
-            };
-            this.ok = (value) => new Ok(value, schema, buffer);
-            this.err = (error) => new Err(error, schema, buffer);
+            if (hasScope) {
+                if (!spanLogger)
+                    throw new TypeError('SpanContext scope capability requires a logger');
+                this.setScope = (attributes) => {
+                    spanLogger._setScope(attributes ?? {});
+                };
+            }
+            if (hasResult) {
+                this.ok = (value) => new Ok(value, this);
+                this.err = (error) => new Err(error, this);
+            }
             //#endregion smoo/lmao!n/codegen-destructured-context
             //#region smoo/lmao!n/context-flow-span-promise
             // 01c "Why span() Is Promise-Based" + "Child Span Creation via span()" + "spanSync()".
@@ -346,61 +455,63 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
             // 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 = function span(nameOrLine, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10, _arg11) {
-                // 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(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(name, fn) {
-                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 = function span(nameOrLine, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10, _arg11) {
+                    // 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(arguments[fnIdx], self._physicalLayoutPlan, self._spanBuffer._opMetadata);
+                    const childCtx = asSpanContextInstance(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(name, op) {
+                    const callsitePlan = op.callsitePlan;
+                    const childCtx = asSpanContextInstance(callsitePlan.newCtx0(self));
+                    return self.spanSync0(0, name, childCtx, callsitePlan, op.fn);
+                };
+            }
             //#endregion smoo/lmao!n/context-flow-span-promise
         }
         // =========================================================================
@@ -410,35 +521,43 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
             return true;
         }
         get module() {
-            return this._buffer._opMetadata;
+            return this._spanBuffer._opMetadata;
         }
         get callee_package() {
-            return this._buffer._opMetadata.package_name;
+            return this._spanBuffer._opMetadata.package_name;
         }
         get callee_file() {
-            return this._buffer._opMetadata.package_file;
+            return this._spanBuffer._opMetadata.package_file;
         }
         get callee_line() {
             // 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() {
-            return this._buffer._opMetadata.git_sha;
+            return this._spanBuffer._opMetadata.git_sha;
         }
         get buffer() {
-            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() {
-            return this._buffer._scopeValues;
+            return this._spanBuffer._scopeValues;
         }
         //#endregion smoo/lmao!n/scope-attributes.read
         // =========================================================================
         // Internal methods (on prototype)
         // =========================================================================
+        _appendWriterEntry(entryType) {
+            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.
@@ -446,7 +565,7 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
          * Transformer emits: ctx.span0(line, name, ctx._newCtx0(), fn)
          */
         _newCtx0() {
-            return createInheritedContext(this);
+            return asSpanContextInstance(this._physicalLayoutPlan.newCtx0(this));
         }
         /**
          * Create a new child context with prototype chain inheritance + user overrides.
@@ -455,7 +574,7 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
          * Transformer emits: ctx.span0(line, name, ctx._newCtx1({ requestId }), fn)
          */
         _newCtx1(overrides) {
-            return createInheritedContextWithOverrides(this, overrides);
+            return asSpanContextInstance(this._physicalLayoutPlan.newCtx1(this, overrides));
         }
         /**
          * Complete child span context setup - creates buffer, registers with parent.
@@ -468,116 +587,27 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
          * @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(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata) {
-            // 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);
-            if (!isSpanBufferForSchema(createdBuffer, childSchema)) {
-                throw new TypeError('Child span buffer does not match the requested schema');
-            }
+        // _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, line, name, callsitePlan, opMetadata) {
+            const childSchema = callsitePlan.schema;
+            const createdBuffer = this._spanBuffer._traceRoot.tracer.bufferStrategy.createChildSpanBuffer(this._spanBuffer, this._spanBuffer._opMetadata, opMetadata, callsitePlan.capacityTier, childSchema, callsitePlan.SpanBufferClass);
             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 = function span(nameOrLine, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7, _arg8, _arg9, _arg10, _arg11) {
-                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(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(name, fn) {
-                const newChildCtx = ctx._newCtx0();
-                return ctx.spanSync0(0, name, newChildCtx, getBufferConstructor(childBuffer), undefined, childBuffer._opMetadata, fn);
-            };
-            ctx.ok = function ok(value) {
-                return new Ok(value, childSchema, childBuffer);
-            };
-            ctx.err = function err(error) {
-                return new Err(error, childSchema, childBuffer);
-            };
-            ctx.setScope = function setScope(attributes) {
-                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(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
         //#region smoo/lmao!n/lmao-entry-span-lifecycle-entry-types.exception
@@ -586,8 +616,7 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
          * Called in catch blocks of span methods.
          */
         _spanException(childBuffer, error) {
-            // 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);
@@ -596,18 +625,466 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
             }
         }
         //#endregion smoo/lmao!n/lmao-entry-span-lifecycle-entry-types.exception
+        _spanAutoPre(line, name, op) {
+            const child = asSpanContextInstance(op.callsitePlan.newCtx0(this));
+            return this._spanPre(child, line, name, op.callsitePlan, op.metadata);
+        }
+        spanAuto0(line, name, op) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync0(ctx, buffer, op, first) {
+            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(line, name, op, a1) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync1(ctx, buffer, op, first, a1) {
+            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(line, name, op, a1, a2) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync2(ctx, buffer, op, first, a1, a2) {
+            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(line, name, op, a1, a2, a3) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync3(ctx, buffer, op, first, a1, a2, a3) {
+            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(line, name, op, a1, a2, a3, a4) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync4(ctx, buffer, op, first, a1, a2, a3, a4) {
+            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(line, name, op, a1, a2, a3, a4, a5) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync5(ctx, buffer, op, first, a1, a2, a3, a4, a5) {
+            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(line, name, op, a1, a2, a3, a4, a5, a6) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync6(ctx, buffer, op, first, a1, a2, a3, a4, a5, a6) {
+            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(line, name, op, a1, a2, a3, a4, a5, a6, a7) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync7(ctx, buffer, op, first, a1, a2, a3, a4, a5, a6, a7) {
+            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(line, name, op, a1, a2, a3, a4, a5, a6, a7, a8) {
+            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);
+                }
+            }
+        }
+        async _spanAutoAsync8(ctx, buffer, op, first, a1, a2, a3, a4, a5, a6, a7, a8) {
+            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(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        spanSync0(line, name, childCtx, callsitePlan, fn) {
+            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;
             }
@@ -619,13 +1096,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span0(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span0(line, name, childCtx, callsitePlan, fn) {
+            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;
             }
@@ -637,13 +1114,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span1(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span1(line, name, childCtx, callsitePlan, fn, a1) {
+            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;
             }
@@ -655,13 +1132,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span2(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1, a2) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span2(line, name, childCtx, callsitePlan, fn, a1, a2) {
+            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;
             }
@@ -673,13 +1150,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span3(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1, a2, a3) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span3(line, name, childCtx, callsitePlan, fn, a1, a2, a3) {
+            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;
             }
@@ -691,13 +1168,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span4(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1, a2, a3, a4) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span4(line, name, childCtx, callsitePlan, fn, a1, a2, a3, a4) {
+            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;
             }
@@ -709,13 +1186,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span5(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1, a2, a3, a4, a5) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span5(line, name, childCtx, callsitePlan, fn, a1, a2, a3, a4, a5) {
+            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;
             }
@@ -727,13 +1204,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span6(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1, a2, a3, a4, a5, a6) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span6(line, name, childCtx, callsitePlan, fn, a1, a2, a3, a4, a5, a6) {
+            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;
             }
@@ -745,13 +1222,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span7(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1, a2, a3, a4, a5, a6, a7) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span7(line, name, childCtx, callsitePlan, fn, a1, a2, a3, a4, a5, a6, a7) {
+            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;
             }
@@ -763,13 +1240,13 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
                 buffer._traceRoot.tracer.onSpanEnd(buffer);
             }
         }
-        async span8(line, name, childCtx, SpanBufferClass, remappedViewClass, opMetadata, fn, a1, a2, a3, a4, a5, a6, a7, a8) {
-            const ctx = this._spanPre(childCtx, line, name, SpanBufferClass, remappedViewClass, opMetadata);
-            const buffer = ctx._buffer;
+        async span8(line, name, childCtx, callsitePlan, fn, a1, a2, a3, a4, a5, a6, a7, a8) {
+            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;
             }
@@ -783,6 +1260,7 @@ export function createSpanContextClass(_schemaOnly, logBinding) {
         }
     }
     const SpanContextCtor = SpanContextImpl;
+    cache.set(cacheKey, SpanContextCtor);
     return SpanContextCtor;
 }
 // =============================================================================