@smoothbricks/lmao 0.1.0

package/dist/lib/logBinding.d.ts

@@ -0,0 +1,63 @@
+/**
+ * LogBinding - Logging infrastructure binding for ops and buffers
+ *
+ * Represents the binding between a set of operations and their logging infrastructure.
+ * Contains the schema and optional remapping support for prefixed modules.
+ *
+ * Note: Buffer stats (self-tuning capacity) are stored on SpanBufferClass.stats as static
+ * properties, NOT on LogBinding. See agent-todo/opgroup-refactor.md for rationale.
+ *
+ * Per specs:
+ * - 01b2_buffer_self_tuning.md - Self-tuning via SpanBufferClass.stats
+ * - 01e_library_integration_pattern.md - Library prefix/remapping support
+ */
+import type { LogSchema } from './schema/LogSchema.js';
+type SpanBuffer = import('./types.js').AnySpanBuffer;
+/**
+ * RemappedViewConstructor - Constructor type for RemappedBufferView classes.
+ *
+ * Generated at module composition time (cold path) by `generateRemappedBufferViewClass()`.
+ * Used by prefixed modules to wrap SpanBuffer instances for Arrow conversion when
+ * the module's schema columns have been renamed with a prefix.
+ *
+ * The constructor takes a raw SpanBuffer and returns a view that remaps column access
+ * from prefixed names to unprefixed names for tree traversal during Arrow conversion.
+ *
+ * Per specs/lmao/01e_library_integration_pattern.md:
+ * - Hot path: Library writes directly to unprefixed columns (zero overhead)
+ * - Cold path: Arrow conversion uses RemappedBufferView to access via prefixed names
+ */
+export type RemappedViewConstructor = new (buffer: SpanBuffer) => SpanBuffer;
+/**
+ * LogBinding - Everything needed for a group of ops to write logs.
+ *
+ * Represents the binding between a set of operations and their logging infrastructure.
+ * Contains the schema and optional remapping support for prefixed modules.
+ *
+ * Note: Buffer stats (self-tuning capacity) are stored on SpanBufferClass.stats as static
+ * properties, NOT on LogBinding. This avoids sync bugs from having two stat objects and
+ * reduces per-instance memory. See agent-todo/opgroup-refactor.md for rationale.
+ *
+ * Per specs:
+ * - 01b2_buffer_self_tuning.md - Self-tuning via SpanBufferClass.stats
+ * - 01e_library_integration_pattern.md - Library prefix/remapping support
+ *
+ * @property logSchema - The unprefixed schema defining what columns can be written.
+ *   This is the canonical schema. Column names in remappedViewClass will be prefixed versions
+ *   of these field names when a prefix or column mapping has been applied.
+ *
+ * @property remappedViewClass - Optional RemappedBufferView class for prefixed/remapped buffers.
+ *   - When present: the module's ops write to unprefixed columns, but buffers must be wrapped
+ *     in this view for Arrow conversion to access them by prefixed names
+ *   - When absent: buffers can be used directly without remapping
+ *   - Set during module composition when prefix() or mapColumns() is applied (cold path)
+ *   - Used when registering child spans to parent's tree (see op.ts)
+ */
+export interface LogBinding<T extends LogSchema = LogSchema> {
+    /** The unprefixed schema defining what columns exist */
+    readonly logSchema: T;
+    /** Optional RemappedBufferView class for prefixed/remapped buffers */
+    readonly remappedViewClass?: RemappedViewConstructor;
+}
+export {};
+//# sourceMappingURL=logBinding.d.ts.map

package/dist/lib/logBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logBinding.d.ts","sourceRoot":"","sources":["../../src/lib/logBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGvD,KAAK,UAAU,GAAG,OAAO,YAAY,EAAE,aAAa,CAAC;AAErD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,uBAAuB,GAAG,KAAK,MAAM,EAAE,UAAU,KAAK,UAAU,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACzD,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IAEtB,sEAAsE;IACtE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;CACtD"}

package/dist/lib/logBinding.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/op.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Op - Traced operation class and OpMetadata
+ *
+ * This is the single source of truth for the Op class and OpMetadata interface.
+ * Other modules re-export these types for convenience.
+ *
+ * Wraps a user function with automatic span tracking.
+ * Created by defineOp() from the Op-centric API (defineOpContext).
+ *
+ * Per specs/lmao/01l_op_context_pattern.md and specs/lmao/01c_context_flow_and_op_wrappers.md:
+ * - Captures OpMetadata for attribution (package_name, package_file, git_sha, line)
+ * - fn is called by span_op() after span_op creates the SpanBuffer/SpanContext
+ * - Op name is used for metrics tracking (separate from span names)
+ */
+import type { PreEncodedEntry } from '@smoothbricks/arrow-builder';
+import type { RemappedViewConstructor } from './logBinding.js';
+import type { SpanContext } from './opContext/spanContextTypes.js';
+import type { OpContext, OpContextBinding } from './opContext/types.js';
+import type { Result } from './result.js';
+import type { SpanBufferConstructor } from './spanBuffer.js';
+/**
+ * Metadata injected by the transformer into each Op.
+ * These values are determined at compile time from the source location.
+ *
+ * Includes pre-encoded UTF-8 entries for Arrow dictionary building -
+ * encode once at Op definition time, reuse for every span conversion.
+ */
+export interface OpMetadata {
+    /** Op name for metrics tracking (distinct from span names which are provided at call sites) */
+    readonly name: string;
+    /** Package name from package.json */
+    readonly package_name: string;
+    /** File path relative to package root */
+    readonly package_file: string;
+    /** Git SHA at build time */
+    readonly git_sha: string;
+    /** Line number where defineOp was called */
+    readonly line: number;
+    /** Pre-encoded package_name for Arrow dictionary building */
+    readonly package_name_entry: PreEncodedEntry;
+    /** Pre-encoded package_file for Arrow dictionary building */
+    readonly package_file_entry: PreEncodedEntry;
+    /** Pre-encoded git_sha for Arrow dictionary building */
+    readonly git_sha_entry: PreEncodedEntry;
+}
+/**
+ * Op - Traced operation (Phase 2 architecture)
+ *
+ * Per spec 01l lines 436-453 and 01c lines 292-362:
+ * - Wraps a user function with automatic span tracking
+ * - Captures module metadata for attribution
+ * - fn is public and called by span_op() after buffer/context creation
+ *
+ * Type parameter order matches function signature: (ctx: SpanContext<Ctx>, ...args: Args) => Result<S, E>
+ *
+ * Op has TWO names:
+ * - `name`: The Op's name for metrics (invocations, errors, duration tracking)
+ * - Span names are provided at CALL SITE: `await span('contextual-name', myOp, args)`
+ *
+ * Op captures the metadata for source attribution:
+ * - When span() invokes this Op, the Op's metadata becomes buffer._opMetadata (for rows 1+)
+ * - The caller's metadata becomes buffer._callsiteMetadata (for row 0)
+ *
+ * Phase 2 architecture:
+ * - SpanBufferClass carries static schema + stats (shared by all ops from same defineOpContext)
+ * - remappedViewClass only set for prefixed ops (wraps child buffers before adding to _children)
+ * - No LogBinding - stats accessed via SpanBufferClass.stats
+ *
+ * @typeParam Ctx - OpContext with deps, ff, env (contravariant position)
+ * @typeParam Args - Tuple of argument types (excluding ctx)
+ * @typeParam S - Success type of the Result
+ * @typeParam E - Error type of the Result
+ */
+export declare class Op<Ctx extends OpContext, Args extends unknown[], S, E> {
+    /** Op name for metrics, telemetry, and debugging */
+    readonly metadata: OpMetadata;
+    /** Op owns buffer creation - class has static schema + stats shared by all instances */
+    readonly SpanBufferClass: SpanBufferConstructor;
+    /** The user function to execute - called by span_op after context creation (can be sync or async) */
+    readonly fn: (ctx: SpanContext<Ctx>, ...args: Args) => Result<S, E> | Promise<Result<S, E>>;
+    /** Only set for prefixed ops - wraps child buffers during registration */
+    readonly remappedViewClass?: RemappedViewConstructor | undefined;
+    /**
+     * WHY: Carries the OpContextBinding from the factory that created this Op.
+     * Enables downstream consumers (defineAgentOps, OpRegistry) to extract the
+     * LMAO schema for context merging and conflict detection.
+     */
+    readonly _opContextBinding?: OpContextBinding | undefined;
+    constructor(
+    /** Op name for metrics, telemetry, and debugging */
+    metadata: OpMetadata, 
+    /** Op owns buffer creation - class has static schema + stats shared by all instances */
+    SpanBufferClass: SpanBufferConstructor, 
+    /** The user function to execute - called by span_op after context creation (can be sync or async) */
+    fn: (ctx: SpanContext<Ctx>, ...args: Args) => Result<S, E> | Promise<Result<S, E>>, 
+    /** Only set for prefixed ops - wraps child buffers during registration */
+    remappedViewClass?: RemappedViewConstructor | undefined, 
+    /**
+     * WHY: Carries the OpContextBinding from the factory that created this Op.
+     * Enables downstream consumers (defineAgentOps, OpRegistry) to extract the
+     * LMAO schema for context merging and conflict detection.
+     */
+    _opContextBinding?: OpContextBinding | undefined);
+}
+//# sourceMappingURL=op.d.ts.map

package/dist/lib/op.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op.d.ts","sourceRoot":"","sources":["../../src/lib/op.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAM7D;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,+FAA+F;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4BAA4B;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,6DAA6D;IAC7D,QAAQ,CAAC,kBAAkB,EAAE,eAAe,CAAC;IAC7C,6DAA6D;IAC7D,QAAQ,CAAC,kBAAkB,EAAE,eAAe,CAAC;IAC7C,wDAAwD;IACxD,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC;CACzC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,EAAE,CAAC,GAAG,SAAS,SAAS,EAAE,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC;IAE/D,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,UAAU;IAC7B,wFAAwF;IACxF,QAAQ,CAAC,eAAe,EAAE,qBAAqB;IAC/C,qGAAqG;IACrG,QAAQ,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3F,0EAA0E;IAC1E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB;IACpD;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,gBAAgB;;IAb7C,oDAAoD;IAC3C,QAAQ,EAAE,UAAU;IAC7B,wFAAwF;IAC/E,eAAe,EAAE,qBAAqB;IAC/C,qGAAqG;IAC5F,EAAE,EAAE,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3F,0EAA0E;IACjE,iBAAiB,CAAC,EAAE,uBAAuB,YAAA;IACpD;;;;OAIG;IACM,iBAAiB,CAAC,EAAE,gBAAgB,YAAA;CAEhD"}

package/dist/lib/op.js

@@ -0,0 +1,59 @@
+// =============================================================================
+// Op Class
+// =============================================================================
+/**
+ * Op - Traced operation (Phase 2 architecture)
+ *
+ * Per spec 01l lines 436-453 and 01c lines 292-362:
+ * - Wraps a user function with automatic span tracking
+ * - Captures module metadata for attribution
+ * - fn is public and called by span_op() after buffer/context creation
+ *
+ * Type parameter order matches function signature: (ctx: SpanContext<Ctx>, ...args: Args) => Result<S, E>
+ *
+ * Op has TWO names:
+ * - `name`: The Op's name for metrics (invocations, errors, duration tracking)
+ * - Span names are provided at CALL SITE: `await span('contextual-name', myOp, args)`
+ *
+ * Op captures the metadata for source attribution:
+ * - When span() invokes this Op, the Op's metadata becomes buffer._opMetadata (for rows 1+)
+ * - The caller's metadata becomes buffer._callsiteMetadata (for row 0)
+ *
+ * Phase 2 architecture:
+ * - SpanBufferClass carries static schema + stats (shared by all ops from same defineOpContext)
+ * - remappedViewClass only set for prefixed ops (wraps child buffers before adding to _children)
+ * - No LogBinding - stats accessed via SpanBufferClass.stats
+ *
+ * @typeParam Ctx - OpContext with deps, ff, env (contravariant position)
+ * @typeParam Args - Tuple of argument types (excluding ctx)
+ * @typeParam S - Success type of the Result
+ * @typeParam E - Error type of the Result
+ */
+export class Op {
+    metadata;
+    SpanBufferClass;
+    fn;
+    remappedViewClass;
+    _opContextBinding;
+    constructor(
+    /** Op name for metrics, telemetry, and debugging */
+    metadata, 
+    /** Op owns buffer creation - class has static schema + stats shared by all instances */
+    SpanBufferClass, 
+    /** The user function to execute - called by span_op after context creation (can be sync or async) */
+    fn, 
+    /** Only set for prefixed ops - wraps child buffers during registration */
+    remappedViewClass, 
+    /**
+     * WHY: Carries the OpContextBinding from the factory that created this Op.
+     * Enables downstream consumers (defineAgentOps, OpRegistry) to extract the
+     * LMAO schema for context merging and conflict detection.
+     */
+    _opContextBinding) {
+        this.metadata = metadata;
+        this.SpanBufferClass = SpanBufferClass;
+        this.fn = fn;
+        this.remappedViewClass = remappedViewClass;
+        this._opContextBinding = _opContextBinding;
+    }
+}

package/dist/lib/opContext/contextTypes.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Context Type Utilities for Op-Centric API
+ *
+ * Type-level utilities for handling user context property patterns:
+ * - Required at createTrace (null sentinel)
+ * - Optional (undefined sentinel)
+ * - Has default (non-null, non-undefined value)
+ *
+ * Also includes reserved property validation to prevent conflicts with SpanContext.
+ */
+/**
+ * Reserved property names that cannot be used in user context.
+ * These are properties that exist on SpanContext and would cause conflicts.
+ */
+export declare const RESERVED_CONTEXT_PROPS: readonly ["buffer", "tag", "log", "scope", "setScope", "ok", "err", "span", "ff", "deps", "_buffer", "_schema", "_spanLogger"];
+/**
+ * Union type of all reserved context property names.
+ */
+export type ReservedContextProp = (typeof RESERVED_CONTEXT_PROPS)[number];
+/**
+ * Context property patterns:
+ *
+ * 1. Required at createTrace (null sentinel):
+ *    `env: null as Env` -> must provide at createTrace, type is Env in SpanContext
+ *
+ * 2. Optional (undefined sentinel):
+ *    `userId: undefined as string | undefined` -> optional at createTrace, may be undefined in SpanContext
+ *
+ * 3. Has default (non-null, non-undefined value):
+ *    `config: { retryCount: 3 }` -> can override at createTrace, uses default if not provided
+ */
+/**
+ * Extract keys where value is exactly `null` (required at trace creation).
+ * These MUST be provided at createTrace().
+ */
+export type NullKeys<T> = {
+    [K in keyof T]: [T[K]] extends [null] ? K : null extends T[K] ? (undefined extends T[K] ? never : K) : never;
+}[keyof T];
+/**
+ * Extract keys where value is `undefined` or includes `undefined` (optional).
+ * These are optional at createTrace() and may be undefined in SpanContext.
+ */
+export type UndefinedKeys<T> = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+/**
+ * Extract keys with concrete values (neither null nor undefined).
+ * These have defaults and are optional to override at createTrace().
+ */
+export type DefaultKeys<T> = {
+    [K in keyof T]: null extends T[K] ? never : undefined extends T[K] ? never : K;
+}[keyof T];
+/**
+ * Transform user context for SpanContext.
+ * - Null properties become their non-null type (filled at createTrace)
+ * - Undefined properties stay as potentially undefined
+ * - Default properties stay as-is
+ */
+export type ResolvedContext<UserCtx> = {
+    readonly [K in keyof UserCtx]: null extends UserCtx[K] ? undefined extends UserCtx[K] ? UserCtx[K] : Exclude<UserCtx[K], null> : UserCtx[K];
+};
+/**
+ * What MUST be provided at createTrace() - only null sentinel properties.
+ */
+export type RequiredContextParams<UserCtx> = {
+    [K in NullKeys<UserCtx>]: Exclude<UserCtx[K], null>;
+};
+/**
+ * What CAN be provided at createTrace() - optional and default properties.
+ */
+export type OptionalContextParams<UserCtx> = {
+    [K in UndefinedKeys<UserCtx> | DefaultKeys<UserCtx>]?: undefined extends UserCtx[K] ? UserCtx[K] : UserCtx[K];
+};
+/**
+ * Combined context params for createTrace().
+ * - Null props are REQUIRED (must provide)
+ * - Undefined props are OPTIONAL (can provide or omit)
+ * - Default props are OPTIONAL (can override or use default)
+ */
+export type TraceContextParams<UserCtx> = RequiredContextParams<UserCtx> & OptionalContextParams<UserCtx>;
+/**
+ * Validate that user context doesn't use reserved property names.
+ * Returns `never` with descriptive error if validation fails.
+ */
+export type ValidateUserContext<UserCtx> = keyof UserCtx extends infer K ? K extends ReservedContextProp ? {
+    __error: `'${K & string}' is a reserved SpanContext property and cannot be used in ctx`;
+} : UserCtx : UserCtx;
+//# sourceMappingURL=contextTypes.d.ts.map

package/dist/lib/opContext/contextTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextTypes.d.ts","sourceRoot":"","sources":["../../../src/lib/opContext/contextTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,gIAgBzB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAM1E;;;;;;;;;;;GAWG;AAEH;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,KAAK;CAC7G,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;KAC5B,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CACnD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC;CAC/E,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,OAAO,IAAI;IACrC,QAAQ,EAAE,CAAC,IAAI,MAAM,OAAO,GAAG,IAAI,SAAS,OAAO,CAAC,CAAC,CAAC,GAClD,SAAS,SAAS,OAAO,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,CAAC,CAAC,GACV,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAC3B,OAAO,CAAC,CAAC,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAAC,OAAO,IAAI;KAC1C,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CACpD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,CAAC,OAAO,IAAI;KAC1C,CAAC,IAAI,aAAa,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,SAAS,SAAS,OAAO,CAAC,CAAC,CAAC,GAC/E,OAAO,CAAC,CAAC,CAAC,GACV,OAAO,CAAC,CAAC,CAAC;CACf,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAAC,OAAO,IAAI,qBAAqB,CAAC,OAAO,CAAC,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;AAE1G;;;GAGG;AACH,MAAM,MAAM,mBAAmB,CAAC,OAAO,IAAI,MAAM,OAAO,SAAS,MAAM,CAAC,GACpE,CAAC,SAAS,mBAAmB,GAC3B;IAAE,OAAO,EAAE,IAAI,CAAC,GAAG,MAAM,gEAAgE,CAAA;CAAE,GAC3F,OAAO,GACT,OAAO,CAAC"}

package/dist/lib/opContext/contextTypes.js

@@ -0,0 +1,34 @@
+/**
+ * Context Type Utilities for Op-Centric API
+ *
+ * Type-level utilities for handling user context property patterns:
+ * - Required at createTrace (null sentinel)
+ * - Optional (undefined sentinel)
+ * - Has default (non-null, non-undefined value)
+ *
+ * Also includes reserved property validation to prevent conflicts with SpanContext.
+ */
+// =============================================================================
+// RESERVED PROPERTY NAMES
+// =============================================================================
+/**
+ * Reserved property names that cannot be used in user context.
+ * These are properties that exist on SpanContext and would cause conflicts.
+ */
+export const RESERVED_CONTEXT_PROPS = [
+    // Core SpanContext properties
+    'buffer',
+    'tag',
+    'log',
+    'scope',
+    'setScope',
+    'ok',
+    'err',
+    'span',
+    'ff',
+    'deps',
+    // Internal properties
+    '_buffer',
+    '_schema',
+    '_spanLogger',
+];

package/dist/lib/opContext/createOpGroup.d.ts

@@ -0,0 +1,57 @@
+/**
+ * OpGroup Creation - Class-based architecture for Phase 2
+ *
+ * Creates OpGroups as class instances with ops as own properties.
+ * Enables V8 hidden class optimization and cleaner API (`.opName` not `.ops.opName`).
+ *
+ * Why class-based:
+ * - Private fields (#columnMapping) don't affect hidden class (truly hidden, no enumeration)
+ * - Ops as own properties enable direct access and predictable object shape
+ * - prefix()/mapColumns() create new instances with same SpanBufferClass (shared stats)
+ * - Only remappedViewClass differs between original and prefixed op instances
+ *
+ * Internal properties (_logSchema, _flags, etc.) are prefixed with underscore to avoid
+ * collision with user-defined op names. Public interfaces hide these from intellisense.
+ *
+ * @module opContext/createOpGroup
+ */
+import type { OpGroup, OpGroupOps } from './opGroupTypes.js';
+import type { OpContext } from './types.js';
+/**
+ * Create an OpGroup from a schema, flags, and ops
+ *
+ * Why class-based: V8 hidden class optimization - all OpGroups with same ops
+ * have same object shape (private fields don't affect hidden class).
+ *
+ * The ops passed to this function already have a SpanBufferClass attached.
+ * All ops in the same context share the SAME SpanBufferClass instance, which carries:
+ * - Static schema property (shared by all instances)
+ * - Static stats property (shared mutable stats for self-tuning)
+ *
+ * The returned OpGroup can be:
+ * - Used directly as a dependency (ops accessible via ctx.deps.name.opName)
+ * - Prefixed with `.prefix('http')` to namespace all columns
+ * - Mapped with `.mapColumns({ query: 'query', _internal: null })` for fine control
+ *
+ * @param logSchema - The LogSchema defining columns for this group's ops
+ * @param flags - Feature flag schema
+ * @param ops - Record of Op instances belonging to this group
+ * @returns OpGroup with prefix() and mapColumns() methods, ops as own properties
+ *
+ * @example
+ * ```typescript
+ * const httpOps = createOpGroup(httpLogSchema, httpFlags, {
+ *   fetch: fetchOp,
+ *   post: postOp,
+ * });
+ *
+ * // Direct access (Phase 2):
+ * await ctx.deps.http.fetch(url);
+ *
+ * // Wire with prefix:
+ * deps: { http: httpOps.prefix('http') }
+ * // Columns become: http_status, http_url, http_duration, etc.
+ * ```
+ */
+export declare function createOpGroup<Ctx extends OpContext, Ops extends OpGroupOps<Ctx>>(logSchema: Ctx['logSchema'], flags: Ctx['flags'], ops: Ops): OpGroup<Ctx, Ops>;
+//# sourceMappingURL=createOpGroup.d.ts.map

package/dist/lib/opContext/createOpGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createOpGroup.d.ts","sourceRoot":"","sources":["../../../src/lib/opContext/createOpGroup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,KAAK,EAKV,OAAO,EAEP,UAAU,EAGX,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAyX5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,GAAG,SAAS,SAAS,EAAE,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAC9E,SAAS,EAAE,GAAG,CAAC,WAAW,CAAC,EAC3B,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,EACnB,GAAG,EAAE,GAAG,GACP,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAInB"}