@meetless/mla 0.1.4

package/dist/bundles/trace-core.js

@@ -0,0 +1,263 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../trace-core/dist/index.js
+var require_dist = __commonJS({
+  "../trace-core/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.makeTracer = makeTracer2;
+    exports2.makeNoopTracer = makeNoopTracer2;
+    exports2.serializeError = serializeError;
+    var crypto = __importStar(require("crypto"));
+    function nowIso() {
+      return (/* @__PURE__ */ new Date()).toISOString();
+    }
+    function newSpanId() {
+      return crypto.randomBytes(8).toString("hex");
+    }
+    function serializeError(err) {
+      if (err instanceof Error) {
+        return { message: err.message, name: err.name, stack: err.stack };
+      }
+      return { message: String(err) };
+    }
+    var SpanImpl = class {
+      spanId;
+      parentSpanId;
+      name;
+      startTime;
+      input;
+      output;
+      status;
+      endTime;
+      error;
+      attributes;
+      events;
+      constructor(opts) {
+        this.spanId = newSpanId();
+        this.parentSpanId = opts.parent?.spanId ?? null;
+        this.name = opts.name;
+        this.startTime = nowIso();
+        this.endTime = null;
+        this.status = null;
+        this.input = opts.input;
+        this.attributes = {};
+        this.events = [];
+      }
+      end(opts) {
+        if (this.status !== null)
+          return;
+        this.status = opts.status;
+        this.endTime = nowIso();
+        if (opts.output !== void 0)
+          this.output = opts.output;
+        if (opts.error !== void 0)
+          this.error = opts.error;
+      }
+      setAttribute(key, value) {
+        this.attributes[key] = value;
+      }
+      addEvent(name, attributes) {
+        this.events.push({ name, time: nowIso(), attributes });
+      }
+      isEnded() {
+        return this.status !== null;
+      }
+      // Snapshot for flush. Aborted-at-flush logic: if the span never ended (CLI
+      // killed mid-call), serialize as status: "aborted" + endTime = flush time,
+      // so Langfuse shows exactly the place we lost the run.
+      toJSON(flushTime) {
+        const status = this.status ?? "aborted";
+        const endTime = this.endTime ?? flushTime;
+        const span = {
+          spanId: this.spanId,
+          parentSpanId: this.parentSpanId,
+          name: this.name,
+          startTime: this.startTime,
+          endTime,
+          status
+        };
+        if (this.input !== void 0)
+          span.input = this.input;
+        if (this.output !== void 0)
+          span.output = this.output;
+        if (this.error !== void 0) {
+          span.attributes = { ...this.attributes, error: serializeError(this.error) };
+        } else if (Object.keys(this.attributes).length > 0) {
+          span.attributes = { ...this.attributes };
+        }
+        if (this.events.length > 0)
+          span.events = [...this.events];
+        return span;
+      }
+    };
+    var TracerImpl = class {
+      traceId;
+      root;
+      children;
+      rootImpl;
+      client;
+      flushFn;
+      rootEnded;
+      flushed;
+      constructor(opts) {
+        this.traceId = opts.traceId;
+        this.client = opts.client;
+        this.flushFn = opts.flushFn ?? defaultNoFlush;
+        this.children = [];
+        this.rootImpl = new SpanImpl({ name: opts.rootName, parent: null });
+        this.root = this.rootImpl;
+        this.rootEnded = false;
+        this.flushed = false;
+      }
+      startSpan(opts) {
+        const parent = opts.parent ?? this.root;
+        const child = new SpanImpl({ name: opts.name, parent, input: opts.input });
+        this.children.push(child);
+        return child;
+      }
+      endRoot(opts) {
+        if (this.rootEnded)
+          return;
+        this.rootEnded = true;
+        this.rootImpl.end(opts);
+      }
+      snapshot() {
+        const flushTime = nowIso();
+        return {
+          rootSpan: this.rootImpl.toJSON(flushTime),
+          spans: this.children.map((c) => c.toJSON(flushTime))
+        };
+      }
+      async flush() {
+        if (this.flushed)
+          return;
+        this.flushed = true;
+        const { rootSpan, spans } = this.snapshot();
+        const payload = {
+          traceId: this.traceId,
+          rootSpan,
+          spans,
+          client: this.client
+        };
+        await this.flushFn(payload);
+      }
+    };
+    async function defaultNoFlush(_payload) {
+    }
+    function makeTracer2(opts) {
+      return new TracerImpl(opts);
+    }
+    function makeNoopTracer2(opts) {
+      const noopHandle = {
+        spanId: "noop",
+        parentSpanId: null,
+        end() {
+        },
+        setAttribute() {
+        },
+        addEvent() {
+        },
+        isEnded() {
+          return true;
+        }
+      };
+      const emptyRoot = {
+        spanId: "noop",
+        parentSpanId: null,
+        name: "noop",
+        startTime: nowIso(),
+        endTime: nowIso(),
+        status: "ok"
+      };
+      return {
+        traceId: opts.traceId,
+        root: noopHandle,
+        startSpan: () => noopHandle,
+        endRoot: () => void 0,
+        snapshot: () => ({ rootSpan: emptyRoot, spans: [] }),
+        flush: async () => void 0
+      };
+    }
+  }
+});
+
+// <stdin>
+var stdin_exports = {};
+__export(stdin_exports, {
+  makeNoopTracer: () => import_trace_core.makeNoopTracer,
+  makeTracer: () => import_trace_core.makeTracer
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_trace_core = __toESM(require_dist());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeNoopTracer,
+  makeTracer
+});