@smoothbricks/lmao 0.2.1 → 0.2.3

package/src/lib/result.ts

@@ -31,9 +31,8 @@
  * ```
  */
 
-import { createResultWriter, type ResultWriter } from './codegen/fixedPositionWriterGenerator.js';
+import type { ResultWriter, WriterState } from './codegen/fixedPositionWriterGenerator.js';
 import type { InferSchema, LogSchema } from './schema/types.js';
-import type { AnySpanBuffer } from './types.js';
 
 // =============================================================================
 // TAGGED ERROR INTERFACE
@@ -68,20 +67,10 @@ type BoundResultWriter<T extends LogSchema, R, E> = ResultWriter<T, R, E>;
 
 function ensureResultWriter<T extends LogSchema, R, E>(
   writer: BoundResultWriter<T, R, E> | undefined,
-  schema: T | undefined,
-  buffer: AnySpanBuffer | undefined,
-  resultOrError: R | E,
-  isError: boolean,
+  state: WriterState | undefined,
 ): BoundResultWriter<T, R, E> | undefined {
-  if (writer) {
-    return writer;
-  }
-
-  if (!schema || !buffer) {
-    return undefined;
-  }
-
-  return createResultWriter<T, R, E>(schema, buffer, resultOrError, isError);
+  if (writer || !state) return writer;
+  return new state._physicalLayoutPlan.ResultWriterClass<T, R, E>(state);
 }
 
 function isErrPredicate<E>(value: ErrMatcher<E>): value is ErrPredicate<E> {
@@ -123,19 +112,18 @@ function createCodeErrorValue<Code extends string, Fields extends object>(
 export class Ok<V, T extends LogSchema = LogSchema> {
   readonly value: V;
 
-  private readonly _schema: T | undefined;
-  private readonly _buffer: AnySpanBuffer | undefined;
-  private _writer: BoundResultWriter<T, V, never> | undefined;
+  private readonly _state: WriterState | undefined;
+  private declare _writer: BoundResultWriter<T, V, never> | undefined;
 
-  constructor(value: V, schema?: T, buffer?: AnySpanBuffer) {
+  constructor(value: V, state?: WriterState) {
     this.value = value;
-    this._schema = schema;
-    this._buffer = buffer;
+    this._state = state;
   }
 
   private _resultWriter(): BoundResultWriter<T, V, never> | undefined {
-    this._writer = ensureResultWriter<T, V, never>(this._writer, this._schema, this._buffer, this.value, false);
-    return this._writer;
+    const writer = ensureResultWriter<T, V, never>(this._writer, this._state);
+    if (writer) this._writer = writer;
+    return writer;
   }
 
   /** Discriminant for type narrowing. */
@@ -172,7 +160,7 @@ export class Ok<V, T extends LogSchema = LogSchema> {
 
   /** Transform the success value. */
   map<U>(fn: (value: V) => U): Ok<U, T> {
-    return new Ok<U, T>(fn(this.value), this._schema, this._buffer);
+    return new Ok<U, T>(fn(this.value), this._state);
   }
 
   /** No-op for Ok (error transformation). */
@@ -270,19 +258,18 @@ export class Ok<V, T extends LogSchema = LogSchema> {
 export class Err<E, T extends LogSchema = LogSchema> {
   readonly error: E;
 
-  private readonly _schema: T | undefined;
-  private readonly _buffer: AnySpanBuffer | undefined;
-  private _writer: BoundResultWriter<T, never, E> | undefined;
+  private readonly _state: WriterState | undefined;
+  private declare _writer: BoundResultWriter<T, never, E> | undefined;
 
-  constructor(error: E, schema?: T, buffer?: AnySpanBuffer) {
+  constructor(error: E, state?: WriterState) {
     this.error = error;
-    this._schema = schema;
-    this._buffer = buffer;
+    this._state = state;
   }
 
   private _resultWriter(): BoundResultWriter<T, never, E> | undefined {
-    this._writer = ensureResultWriter<T, never, E>(this._writer, this._schema, this._buffer, this.error, true);
-    return this._writer;
+    const writer = ensureResultWriter<T, never, E>(this._writer, this._state);
+    if (writer) this._writer = writer;
+    return writer;
   }
 
   /** Discriminant for type narrowing. */
@@ -349,7 +336,7 @@ export class Err<E, T extends LogSchema = LogSchema> {
 
   /** Transform the error. */
   mapErr<F>(fn: (error: E) => F): Err<F, T> {
-    return new Err<F, T>(fn(this.error), this._schema, this._buffer);
+    return new Err<F, T>(fn(this.error), this._state);
   }
 
   /** No-op for Err (returns self). */

package/src/lib/runtimeHint.ts

@@ -0,0 +1,98 @@
+export const RUNTIME_HINT_INITIAL_CAPACITY_MASK = 0x0000ffff;
+
+export const RUNTIME_HINT_TAG = 0x00010000;
+export const RUNTIME_HINT_LOG = 0x00020000;
+export const RUNTIME_HINT_FF = 0x00040000;
+export const RUNTIME_HINT_SPAN = 0x00080000;
+export const RUNTIME_HINT_RESULT = 0x00100000;
+export const RUNTIME_HINT_SCOPE = 0x00200000;
+export const RUNTIME_HINT_DEPS = 0x00400000;
+export const RUNTIME_HINT_CAPABILITIES_MASK = 0x007f0000;
+export const RUNTIME_HINT_ANALYZED_VALID = 0x00800000;
+export const RUNTIME_HINT_MESSAGE_LAYOUT_STATIC_ONLY = 0x01000000;
+export const RUNTIME_HINT_MESSAGE_LAYOUT_DYNAMIC_ONLY = 0x02000000;
+export const RUNTIME_HINT_MESSAGE_LAYOUT_MIXED = 0x03000000;
+export const RUNTIME_HINT_MESSAGE_LAYOUT_MASK = 0x03000000;
+export const RUNTIME_HINT_MESSAGE_PHYSICAL_PACKED = 0x04000000;
+export const RUNTIME_HINT_MESSAGE_PHYSICAL_SPECIALIZED = 0x08000000;
+export const RUNTIME_HINT_MESSAGE_PHYSICAL_MASK = 0x0c000000;
+export const RUNTIME_HINT_RESERVED_MASK = 0xf0000000;
+
+export const RUNTIME_HINT_FULL_CAPABILITIES = RUNTIME_HINT_CAPABILITIES_MASK;
+export type MessageLayoutFamily = 'static-only' | 'mixed' | 'dynamic-only';
+export type MessagePhysicalLayout = 'current' | 'specialized' | 'packed';
+
+export interface DecodedRuntimeHint {
+  readonly analyzed: boolean;
+  readonly initialCapacity: number | undefined;
+  readonly capabilities: number;
+  readonly messageLayoutFamily: MessageLayoutFamily;
+  readonly messagePhysicalLayout: MessagePhysicalLayout;
+}
+
+export function isRuntimeHintAnalyzed(runtimeHint: number): boolean {
+  return (
+    Number.isInteger(runtimeHint) &&
+    runtimeHint >= 0 &&
+    runtimeHint <= 0xffffffff &&
+    (runtimeHint & RUNTIME_HINT_RESERVED_MASK) === 0 &&
+    (runtimeHint & RUNTIME_HINT_ANALYZED_VALID) !== 0
+  );
+}
+
+export function runtimeHintInitialCapacity(runtimeHint: number): number | undefined {
+  if (!isRuntimeHintAnalyzed(runtimeHint)) return undefined;
+  const capacity = runtimeHint & RUNTIME_HINT_INITIAL_CAPACITY_MASK;
+  return capacity < 2 ? undefined : capacity;
+}
+
+export function runtimeHintHasCapability(runtimeHint: number, capability: number): boolean {
+  return !isRuntimeHintAnalyzed(runtimeHint) || (runtimeHint & capability) !== 0;
+}
+
+export function runtimeHintMessageLayoutFamily(runtimeHint: number): MessageLayoutFamily {
+  if (!isRuntimeHintAnalyzed(runtimeHint)) return 'mixed';
+
+  switch (runtimeHint & RUNTIME_HINT_MESSAGE_LAYOUT_MASK) {
+    case RUNTIME_HINT_MESSAGE_LAYOUT_STATIC_ONLY:
+      return 'static-only';
+    case RUNTIME_HINT_MESSAGE_LAYOUT_DYNAMIC_ONLY:
+      return 'dynamic-only';
+    case RUNTIME_HINT_MESSAGE_LAYOUT_MIXED:
+      return 'mixed';
+    default:
+      return 'mixed';
+  }
+}
+
+export function runtimeHintMessagePhysicalLayout(runtimeHint: number): MessagePhysicalLayout {
+  if (!isRuntimeHintAnalyzed(runtimeHint)) return 'current';
+  switch (runtimeHint & RUNTIME_HINT_MESSAGE_PHYSICAL_MASK) {
+    case RUNTIME_HINT_MESSAGE_PHYSICAL_PACKED:
+      return 'packed';
+    case RUNTIME_HINT_MESSAGE_PHYSICAL_SPECIALIZED:
+      return 'specialized';
+    default:
+      return 'current';
+  }
+}
+
+export function decodeRuntimeHint(runtimeHint: number): DecodedRuntimeHint {
+  if (!isRuntimeHintAnalyzed(runtimeHint)) {
+    return {
+      analyzed: false,
+      initialCapacity: undefined,
+      capabilities: RUNTIME_HINT_FULL_CAPABILITIES,
+      messageLayoutFamily: 'mixed',
+      messagePhysicalLayout: 'current',
+    };
+  }
+
+  return {
+    analyzed: true,
+    initialCapacity: runtimeHintInitialCapacity(runtimeHint),
+    capabilities: runtimeHint & RUNTIME_HINT_CAPABILITIES_MASK,
+    messageLayoutFamily: runtimeHintMessageLayoutFamily(runtimeHint),
+    messagePhysicalLayout: runtimeHintMessagePhysicalLayout(runtimeHint),
+  };
+}

package/src/lib/schema/__tests__/featureFlags.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from 'bun:test';
 import '../../__tests__/test-helpers.js';
 import { createTestTracerOptions } from '../../__tests__/test-helpers.js';
 import { defineOpContext } from '../../defineOpContext.js';
+import { resolveEntryType } from '../../resolveMessage.js';
 import { TestTracer } from '../../tracers/TestTracer.js';
 import type { AnySpanBuffer } from '../../types.js';
 import { S } from '../builder.js';
@@ -20,7 +21,7 @@ function countEntryType(buffer: AnySpanBuffer, entryType: number): number {
   while (current) {
     const writeIndex = current._writeIndex;
     for (let i = 0; i < writeIndex; i++) {
-      if (current.entry_type[i] === entryType) {
+      if (resolveEntryType(current, i) === entryType) {
         count++;
       }
     }

package/src/lib/schema/builder.ts

@@ -132,7 +132,7 @@ const schemaBuilderImpl: SchemaBuilder = {
    * - S.enum(['CREATE', 'READ', 'UPDATE', 'DELETE']) - for tag attributes
    * - S.enum(['dev', 'staging', 'prod']).default('dev').sync() - feature flag
    */
-  enum: <T extends readonly string[]>(values: T): SchemaOrFlagBuilder<T[number]> & LazyEnumSchema<T[number]> => {
+  enum: <const T extends readonly string[]>(values: T): SchemaOrFlagBuilder<T[number]> & LazyEnumSchema<T[number]> => {
     const schema = ArrowS.enum(values);
     return createSchemaWithFlagBuilder(schema);
   },

package/src/lib/schema/types.ts

@@ -207,7 +207,7 @@ export interface SchemaBuilder {
    * Use for: Operations, HTTP methods, entry types, status enums
    * Example: S.enum(['CREATE', 'READ', 'UPDATE', 'DELETE'])
    */
-  enum<T extends readonly string[]>(values: T): SchemaOrFlagBuilder<T[number]>;
+  enum<const T extends readonly string[]>(values: T): SchemaOrFlagBuilder<T[number]>;
 
   /**
    * Category - Values that often repeat (limited cardinality)

package/src/lib/span-buffer/aot/v1.ts

@@ -0,0 +1,26 @@
+import { checkCapacityTuning } from '../../capacityTuning.js';
+import { EMPTY_SCOPE, materializeCompiledSpanBufferClass } from '../../spanBuffer.js';
+import { copyThreadIdTo, getThreadId } from '../../threadId.js';
+
+const SPAN_BUFFER_AOT_ABI_SYMBOL = Symbol.for('@smoothbricks/lmao/span-buffer/aot/v1');
+
+const spanBufferAotRuntime = Object.freeze({
+  EMPTY_SCOPE,
+  checkCapacityTuning,
+  copyThreadIdTo,
+  getThreadId,
+  materializeCompiledSpanBufferClass,
+});
+
+const existingRuntime = Reflect.get(globalThis, SPAN_BUFFER_AOT_ABI_SYMBOL);
+if (existingRuntime === undefined) {
+  Object.defineProperty(globalThis, SPAN_BUFFER_AOT_ABI_SYMBOL, {
+    value: spanBufferAotRuntime,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+} else if (existingRuntime !== spanBufferAotRuntime) {
+  // invariant throw: one realm must expose exactly one canonical SpanBuffer AOT ABI.
+  throw new TypeError('Conflicting LMAO SpanBuffer AOT runtime registrations');
+}