@smoothbricks/lmao 0.2.2 → 0.3.0

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/typeGuards.ts

@@ -1,10 +1,14 @@
 /**
- * Type guard functions for runtime type checking
+ * Schema type-guard re-exports.
  *
- * Re-exports schema type guards from arrow-builder and adds lmao-specific guards.
+ * Re-exports the schema introspection guards from arrow-builder so the rest of
+ * the package imports them from a single place.
+ *
+ * NOTE: Do not hand-write `isRecord`/`typeof` guards here. For runtime
+ * validation at trust boundaries use Typia (`typia.is<T>()`) or
+ * `@smoothbricks/validation`'s shared helpers (e.g. `isRecord`).
  */
 
-// Re-export schema type guards from arrow-builder
 export {
   getBinaryEncoder,
   getEnumUtf8,
@@ -13,151 +17,3 @@ export {
   isEnumSchema,
   isSchemaWithMetadata,
 } from '@smoothbricks/arrow-builder';
-
-import type { EvaluationContext, UsageContext } from './defineFeatureFlags.js';
-import type { FeatureFlagDefinition } from './types.js';
-
-/** Narrow unknown to Record<string, unknown> — non-null object with string-keyed access. */
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/**
- * Type guard to check if a value is a FeatureFlagDefinition
- */
-export function isFeatureFlagDefinition(value: unknown): value is FeatureFlagDefinition<string | number | boolean> {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  return (
-    'schema' in value &&
-    'defaultValue' in value &&
-    'evaluationType' in value &&
-    (value.evaluationType === 'sync' || value.evaluationType === 'async')
-  );
-}
-
-/**
- * Type guard to check if a value is a valid EvaluationContext
- */
-export function isEvaluationContext(value: unknown): value is EvaluationContext {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  // EvaluationContext can have various string/number/boolean properties
-  // Check that all values are of valid types
-  for (const key in value) {
-    const val = value[key];
-    if (val !== undefined && typeof val !== 'string' && typeof val !== 'number' && typeof val !== 'boolean') {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Type guard to check if a value is a valid UsageContext
- */
-export function isUsageContext(value: unknown): value is UsageContext {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  // Check action property if present
-  if ('action' in value && typeof value.action !== 'string' && value.action !== undefined) {
-    return false;
-  }
-
-  // Check outcome property if present
-  if ('outcome' in value && value.outcome !== undefined && value.outcome !== 'success' && value.outcome !== 'failure') {
-    return false;
-  }
-
-  // Check value property if present
-  if ('value' in value && typeof value.value !== 'number' && value.value !== undefined) {
-    return false;
-  }
-
-  // Check metadata property if present
-  if ('metadata' in value && value.metadata !== undefined) {
-    if (!isRecord(value.metadata)) {
-      return false;
-    }
-
-    // Validate metadata values
-    const metadata = value.metadata;
-    for (const key in metadata) {
-      const val = metadata[key];
-      if (typeof val !== 'string' && typeof val !== 'number' && typeof val !== 'boolean') {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-/**
- * Type guard to check if a value is a string
- * Useful for narrowing unknown types in safe contexts
- */
-export function isString(value: unknown): value is string {
-  return typeof value === 'string';
-}
-
-/**
- * Type guard to check if a value is a number
- * Useful for narrowing unknown types in safe contexts
- */
-export function isNumber(value: unknown): value is number {
-  return typeof value === 'number' && !Number.isNaN(value);
-}
-
-/**
- * Type guard to check if a value is a boolean
- * Useful for narrowing unknown types in safe contexts
- */
-export function isBoolean(value: unknown): value is boolean {
-  return typeof value === 'boolean';
-}
-
-/**
- * Type guard to check if a value is a primitive type (string | number | boolean)
- * Useful for validating feature flag values and tag attributes
- */
-export function isPrimitive(value: unknown): value is string | number | boolean {
-  return isString(value) || isNumber(value) || isBoolean(value);
-}
-
-/**
- * Type guard to check if a value is a plain object (not array, not null)
- */
-export function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    !Array.isArray(value) &&
-    Object.getPrototypeOf(value) === Object.prototype
-  );
-}
-
-/**
- * Type guard to check if a value is a valid record with primitive values
- * Useful for validating tag attribute objects
- */
-export function isRecordOfPrimitives(value: unknown): value is Record<string, string | number | boolean> {
-  if (!isPlainObject(value)) {
-    return false;
-  }
-
-  for (const key in value) {
-    if (!isPrimitive(value[key])) {
-      return false;
-    }
-  }
-
-  return true;
-}

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');
+}