@rasputin-ai/node 0.2.0 → 0.3.0

package/dist/instrument/node.js

@@ -0,0 +1,532 @@
+// src/auto-instrumentation/node-hooks.ts
+import * as nodeModule from "node:module";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+
+// src/execution-recorder/automatic-runtime.ts
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v1";
+var AUTOMATIC_SOURCE_SEPARATOR = "\0";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+var encodeAutomaticFunctionSource = (source) => [resolve(source.filePath), source.name, String(source.line), String(source.column)].join(
+  AUTOMATIC_SOURCE_SEPARATOR
+);
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v1";
+var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
+var getRegistry = () => {
+  const existing = Reflect.get(globalThis, registrySymbol);
+  if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
+    return existing;
+  }
+  const registry = {
+    __rasputinManifestRegistry: true,
+    files: /* @__PURE__ */ new Map(),
+    generation: 0,
+    uploadedGeneration: 0
+  };
+  Reflect.set(globalThis, registrySymbol, registry);
+  return registry;
+};
+var recordInstrumentationManifestDelta = (filePath, delta) => {
+  const registry = getRegistry();
+  registry.files.set(resolve2(filePath), delta);
+  registry.generation += 1;
+  registry.onDirty?.();
+};
+
+// src/auto-instrumentation/source-classification.ts
+import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
+var sourceExtension = /\.[cm]?[jt]sx?$/i;
+var alwaysExcludedDirectory = /(^|[\\/])(node_modules|coverage|generated|\.git|\.next|\.svelte-kit|\.output|\.vercel|\.rasputin|\.turbo|\.yarn|\.pnpm|\.bun)([\\/]|$)/;
+var buildOutputDirectory = /(^|[\\/])(dist|build|out)([\\/]|$)/;
+var matches = (pattern, value) => {
+  pattern.lastIndex = 0;
+  const result = pattern.test(value);
+  pattern.lastIndex = 0;
+  return result;
+};
+var isWithinRoot = (filePath, root) => {
+  const fromRoot = relative3(resolve3(root), filePath);
+  return fromRoot === "" || !fromRoot.startsWith(`..${sep3}`) && fromRoot !== ".." && !isAbsolute3(fromRoot);
+};
+var isApplicationSource = (filePath, options = {}) => {
+  const absolutePath = resolve3(filePath);
+  if (!sourceExtension.test(absolutePath) || alwaysExcludedDirectory.test(absolutePath))
+    return false;
+  if (options.includeBuildOutput !== true && buildOutputDirectory.test(absolutePath)) return false;
+  if (options.excludedRoots?.some((root) => isWithinRoot(absolutePath, root))) return false;
+  if (options.exclude && matches(options.exclude, absolutePath)) return false;
+  if (options.include && !matches(options.include, absolutePath)) return false;
+  if (options.rootDir) {
+    if (!isWithinRoot(absolutePath, options.rootDir)) return false;
+  }
+  return true;
+};
+
+// src/auto-instrumentation/source-map-locations.ts
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute as isAbsolute4, join, resolve as resolve4 } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { LEAST_UPPER_BOUND, originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
+var sourceMapComment = /(?:\/\/[#@][ \t]*sourceMappingURL=([^\s'"]+)|\/\*[#@][ \t]*sourceMappingURL=([^\s*'"]+)[ \t]*\*\/)\s*$/;
+var decodeDataUrl = (url) => {
+  const base64 = /^data:application\/json(?:;charset=[^;,]+)?;base64,(.+)$/i.exec(url);
+  if (base64?.[1]) return Buffer.from(base64[1], "base64").toString("utf8");
+  const raw = /^data:application\/json(?:;charset=[^;,]+)?,(.+)$/i.exec(url);
+  return raw?.[1] ? decodeURIComponent(raw[1]) : void 0;
+};
+var sourceMapFor = (generatedPath, source) => {
+  const match = sourceMapComment.exec(source);
+  const reference = match?.[1] ?? match?.[2];
+  if (reference?.startsWith("data:")) {
+    const payload = decodeDataUrl(reference);
+    return payload ? { payload, mapUrl: pathToFileURL(generatedPath).href } : void 0;
+  }
+  const mapPath = reference ? resolve4(dirname(generatedPath), reference) : `${generatedPath}.map`;
+  return {
+    payload: readFileSync(mapPath, "utf8"),
+    mapUrl: pathToFileURL(mapPath).href
+  };
+};
+var toFilePath = (source, generatedPath) => {
+  if (source.startsWith("file:")) return fileURLToPath(source);
+  return isAbsolute4(source) ? source : join(dirname(generatedPath), source);
+};
+var createSourceMapLocationMapper = (generatedPath, source) => {
+  try {
+    const sourceMap = sourceMapFor(generatedPath, source);
+    if (!sourceMap) return void 0;
+    const traceMap = new TraceMap(sourceMap.payload, sourceMap.mapUrl);
+    return (generated) => {
+      let original = originalPositionFor(traceMap, {
+        line: generated.line,
+        column: Math.max(0, generated.column - 1)
+      });
+      if (!original.source || original.line == null) {
+        original = originalPositionFor(traceMap, {
+          line: generated.line,
+          column: 0,
+          bias: LEAST_UPPER_BOUND
+        });
+      }
+      if (!original.source || original.line == null) return void 0;
+      return {
+        filePath: toFilePath(original.source, generatedPath),
+        line: original.line,
+        column: (original.column ?? 0) + 1
+      };
+    };
+  } catch {
+    return void 0;
+  }
+};
+
+// src/auto-instrumentation/transform-source.ts
+import { resolve as resolve5 } from "node:path";
+import ts2 from "typescript";
+
+// src/auto-instrumentation/collect-instrumentation-delta.ts
+import ts from "typescript";
+var paramBindingFromName = (name, sourceFile) => {
+  if (ts.isIdentifier(name)) return { kind: "identifier", name: name.text };
+  if (ts.isArrayBindingPattern(name)) {
+    const elements = name.elements.map(
+      (element) => {
+        if (ts.isOmittedExpression(element)) return { kind: "omitted" };
+        const binding = paramBindingFromName(element.name, sourceFile);
+        if (element.dotDotDotToken) return { kind: "rest", binding };
+        return binding;
+      }
+    );
+    return { kind: "array", elements };
+  }
+  const properties = name.elements.map((element) => {
+    const binding = paramBindingFromName(element.name, sourceFile);
+    const key = element.propertyName ? element.propertyName.getText(sourceFile).replace(/^['"]|['"]$/g, "") : ts.isIdentifier(element.name) ? element.name.text : element.name.getText(sourceFile);
+    if (element.dotDotDotToken) {
+      const rest = { kind: "rest", binding };
+      return { key, binding: rest };
+    }
+    return { key, binding };
+  });
+  return { kind: "object", properties };
+};
+var collectFunctionParams = (node, sourceFile) => {
+  const params = [];
+  for (const parameter of node.parameters) {
+    if (ts.isIdentifier(parameter.name) && parameter.name.text === "this") continue;
+    const binding = paramBindingFromName(parameter.name, sourceFile);
+    params.push(parameter.dotDotDotToken ? { kind: "rest", binding } : binding);
+  }
+  return { params, paramNames: identifierNames(params) };
+};
+var identifierNames = (bindings) => {
+  const names = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    if (node.kind === "identifier") {
+      names.add(node.name);
+      return;
+    }
+    if (node.kind === "rest") {
+      walk(node.binding);
+      return;
+    }
+    if (node.kind === "object") {
+      for (const property of node.properties) walk(property.binding);
+      return;
+    }
+    if (node.kind === "array") {
+      for (const element of node.elements) {
+        if (element.kind !== "omitted") walk(element);
+      }
+    }
+  };
+  for (const item of bindings) walk(item);
+  return names;
+};
+var mappedLocation = (sourceFile, position, absolutePath, mapLocation) => {
+  const generated = sourceFile.getLineAndCharacterOfPosition(position);
+  const raw = {
+    filePath: absolutePath,
+    line: generated.line + 1,
+    column: generated.character + 1
+  };
+  return mapLocation ? mapLocation(raw) : raw;
+};
+var unwrapExpression = (expression) => {
+  let current = expression;
+  while (ts.isParenthesizedExpression(current) || ts.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  if (ts.isAwaitExpression(current)) return unwrapExpression(current.expression);
+  return current;
+};
+var calleeFromExpression = (expression, sourceFile) => {
+  const current = unwrapExpression(expression);
+  if (ts.isIdentifier(current)) {
+    return { calleeName: current.text, calleeText: current.text };
+  }
+  if (ts.isPropertyAccessExpression(current) && ts.isIdentifier(current.name)) {
+    return {
+      calleeName: current.name.text,
+      calleeText: current.getText(sourceFile).replace(/\s+/g, "")
+    };
+  }
+  return null;
+};
+var resultBindingForCall = (call) => {
+  let node = call.parent;
+  if (ts.isAwaitExpression(node)) node = node.parent;
+  if (!ts.isVariableDeclaration(node)) return null;
+  if (!ts.isIdentifier(node.name)) return null;
+  const initializer = node.initializer;
+  if (!initializer) return null;
+  const inner = unwrapExpression(initializer);
+  if (inner !== call) return null;
+  return node.name.text;
+};
+var argIdentifiersForCall = (call) => {
+  const identifiers = [];
+  call.arguments?.forEach((argument, index) => {
+    if (ts.isIdentifier(argument)) {
+      identifiers.push({ index, kind: "identifier", name: argument.text });
+      return;
+    }
+    if (!ts.isObjectLiteralExpression(argument)) return;
+    const properties = [];
+    for (const property of argument.properties) {
+      if (ts.isShorthandPropertyAssignment(property)) {
+        properties.push({ key: property.name.text, name: property.name.text });
+        continue;
+      }
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && ts.isIdentifier(property.initializer)) {
+        properties.push({ key: property.name.text, name: property.initializer.text });
+      }
+    }
+    if (properties.length > 0) {
+      identifiers.push({ index, kind: "object", properties });
+    }
+  });
+  return identifiers;
+};
+var collectCallSite = (call, caller, context) => {
+  const callee = calleeFromExpression(call.expression, context.sourceFile);
+  if (!callee) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    call.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  const end = mappedLocation(
+    context.sourceFile,
+    call.end,
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start || !end) return null;
+  return {
+    callerSourceToken: caller.sourceToken,
+    calleeName: callee.calleeName,
+    calleeText: callee.calleeText,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    resultBinding: resultBindingForCall(call),
+    argIdentifiers: argIdentifiersForCall(call)
+  };
+};
+var collectParamDestructure = (declaration, caller, context) => {
+  if (!declaration.initializer || !ts.isIdentifier(declaration.initializer)) return null;
+  if (!ts.isObjectBindingPattern(declaration.name) && !ts.isArrayBindingPattern(declaration.name)) {
+    return null;
+  }
+  const sourceParam = declaration.initializer.text;
+  if (!caller.paramNames.has(sourceParam)) return null;
+  const start = mappedLocation(
+    context.sourceFile,
+    declaration.getStart(context.sourceFile),
+    context.absolutePath,
+    context.mapLocation
+  );
+  if (!start) return null;
+  return {
+    callerSourceToken: caller.sourceToken,
+    sourceParam,
+    filePath: start.filePath,
+    line: start.line,
+    column: start.column,
+    binding: paramBindingFromName(declaration.name, context.sourceFile)
+  };
+};
+
+// src/auto-instrumentation/transform-source.ts
+var scriptKindFor = (filePath) => {
+  if (/\.tsx$/i.test(filePath)) return ts2.ScriptKind.TSX;
+  if (/\.jsx$/i.test(filePath)) return ts2.ScriptKind.JSX;
+  if (/\.[cm]?ts$/i.test(filePath)) return ts2.ScriptKind.TS;
+  return ts2.ScriptKind.JS;
+};
+var functionName = (node, sourceFile) => {
+  if (node.name) return node.name.getText(sourceFile).replace(/^['"]|['"]$/g, "");
+  const parent = node.parent;
+  if (ts2.isVariableDeclaration(parent) && ts2.isIdentifier(parent.name)) return parent.name.text;
+  if (ts2.isPropertyAssignment(parent)) return parent.name.getText(sourceFile);
+  if (ts2.isPropertyDeclaration(parent) && parent.name) return parent.name.getText(sourceFile);
+  const location = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return `anonymous@${location.line + 1}:${location.character + 1}`;
+};
+var functionLocationPosition = (node, sourceFile) => {
+  if (node.name) return node.name.getStart(sourceFile);
+  const parent = node.parent;
+  if ((ts2.isVariableDeclaration(parent) || ts2.isPropertyAssignment(parent)) && parent.name) {
+    return parent.name.getStart(sourceFile);
+  }
+  return node.getStart(sourceFile);
+};
+var bindingValue = (name, sourceFile) => {
+  if (ts2.isIdentifier(name)) return name.text;
+  if (ts2.isArrayBindingPattern(name)) {
+    const values = name.elements.map((element) => {
+      if (ts2.isOmittedExpression(element)) return "";
+      const value = bindingValue(element.name, sourceFile);
+      return element.dotDotDotToken ? `...${value}` : value;
+    });
+    return `[${values.join(",")}]`;
+  }
+  const properties = name.elements.map((element) => {
+    const value = bindingValue(element.name, sourceFile);
+    if (element.dotDotDotToken) return `...${value}`;
+    if (element.propertyName) return `${element.propertyName.getText(sourceFile)}:${value}`;
+    return value;
+  });
+  return `{${properties.join(",")}}`;
+};
+var arrowArguments = (node) => {
+  const values = node.parameters.flatMap((parameter) => {
+    if (ts2.isIdentifier(parameter.name) && parameter.name.text === "this") return [];
+    const value = bindingValue(parameter.name, node.getSourceFile());
+    return [parameter.dotDotDotToken ? `...${value}` : value];
+  });
+  return `[${values.join(",")}]`;
+};
+var isSupportedFunction = (node) => {
+  if (!ts2.isFunctionDeclaration(node) && !ts2.isFunctionExpression(node) && !ts2.isArrowFunction(node) && !ts2.isMethodDeclaration(node) && !ts2.isGetAccessorDeclaration(node) && !ts2.isSetAccessorDeclaration(node)) {
+    return false;
+  }
+  if (!node.body || "asteriskToken" in node && node.asteriskToken) return false;
+  return true;
+};
+var helperDeclaration = (helperName) => `const ${helperName}=(functionId,args,callback)=>{const runtime=Reflect.get(globalThis,Symbol.for(${JSON.stringify(AUTOMATIC_RUNTIME_SYMBOL)}));return runtime?runtime.run(functionId,args,callback):callback()};`;
+var collectWrappedFunction = (node, sourceFile, absolutePath, mapLocation) => {
+  const start = mappedLocation(
+    sourceFile,
+    functionLocationPosition(node, sourceFile),
+    absolutePath,
+    mapLocation
+  );
+  if (!start) return void 0;
+  const end = mappedLocation(sourceFile, node.end, absolutePath, mapLocation) ?? start;
+  const name = functionName(node, sourceFile).replace(/@\d+:\d+$/, "");
+  const { params, paramNames } = collectFunctionParams(node, sourceFile);
+  return {
+    sourceToken: encodeAutomaticFunctionSource({
+      filePath: start.filePath,
+      name,
+      line: start.line,
+      column: start.column
+    }),
+    filePath: start.filePath,
+    name,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    params,
+    paramNames
+  };
+};
+var transformSource = (source, options) => {
+  if (source.includes("@rasputin-ignore-file")) return void 0;
+  const sourceFile = ts2.createSourceFile(
+    options.filePath,
+    source,
+    ts2.ScriptTarget.Latest,
+    true,
+    scriptKindFor(options.filePath)
+  );
+  let helperName = "__rasputinAutoRun__";
+  while (source.includes(helperName)) helperName += "_";
+  const absolutePath = resolve5(options.filePath);
+  const edits = [];
+  let order = 0;
+  const delta = {
+    functions: [],
+    callSites: [],
+    destructures: []
+  };
+  const collectContext = {
+    sourceFile,
+    mapLocation: options.mapLocation,
+    absolutePath
+  };
+  const visit = (node, caller) => {
+    if (isSupportedFunction(node)) {
+      const collected = collectWrappedFunction(node, sourceFile, absolutePath, options.mapLocation);
+      if (!collected) {
+        ts2.forEachChild(node, (child) => visit(child, caller));
+        return;
+      }
+      delta.functions.push(collected);
+      const args = ts2.isArrowFunction(node) ? arrowArguments(node) : "arguments";
+      const asyncCallback = node.modifiers?.some(
+        (modifier) => modifier.kind === ts2.SyntaxKind.AsyncKeyword
+      ) ? "async " : "";
+      if (ts2.isBlock(node.body)) {
+        edits.push({
+          position: node.body.getStart(sourceFile) + 1,
+          text: `return ${helperName}(${JSON.stringify(collected.sourceToken)},${args},${asyncCallback}()=>{`,
+          order: order++
+        });
+        edits.push({ position: node.body.end - 1, text: "});", order: order++ });
+      } else {
+        edits.push({
+          position: node.body.getStart(sourceFile),
+          text: `${helperName}(${JSON.stringify(collected.sourceToken)},${args},${asyncCallback}()=>(`,
+          order: order++
+        });
+        edits.push({ position: node.body.end, text: "))", order: order++ });
+      }
+      ts2.forEachChild(node, (child) => visit(child, collected));
+      return;
+    }
+    if (caller && (ts2.isCallExpression(node) || ts2.isNewExpression(node))) {
+      const site = collectCallSite(node, caller, collectContext);
+      if (site) delta.callSites.push(site);
+    }
+    if (caller && ts2.isVariableDeclaration(node)) {
+      const destructure = collectParamDestructure(node, caller, collectContext);
+      if (destructure) delta.destructures.push(destructure);
+    }
+    ts2.forEachChild(node, (child) => visit(child, caller));
+  };
+  visit(sourceFile);
+  if (edits.length === 0) return void 0;
+  const shebangEnd = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
+  edits.push({ position: shebangEnd, text: helperDeclaration(helperName), order: -1 });
+  edits.sort((left, right) => right.position - left.position || right.order - left.order);
+  let transformed = source;
+  for (const edit of edits) {
+    transformed = `${transformed.slice(0, edit.position)}${edit.text}${transformed.slice(edit.position)}`;
+  }
+  return { code: transformed, delta };
+};
+
+// src/auto-instrumentation/node-hooks.ts
+var supportedFormat = /^(?:module|commonjs)(?:-typescript)?$/;
+var registerHooks2 = nodeModule.registerHooks;
+var sourceText = (source) => {
+  if (typeof source === "string") return source;
+  if (source instanceof ArrayBuffer) return Buffer.from(source).toString("utf8");
+  if (ArrayBuffer.isView(source)) {
+    return Buffer.from(source.buffer, source.byteOffset, source.byteLength).toString("utf8");
+  }
+  return void 0;
+};
+var registerRasputinNodeHooks = (options = {}) => {
+  if (!registerHooks2) {
+    console.warn(
+      "[rasputin] Automatic instrumentation is disabled because it requires Node.js 22.15.0 or newer."
+    );
+    return;
+  }
+  const debug = process.env.RASPUTIN_DEBUG === "1";
+  registerHooks2({
+    load(url, context, nextLoad) {
+      const result = nextLoad(url, context);
+      const format = result.format ?? context.format;
+      if (!url.startsWith("file:") || !format || !supportedFormat.test(format)) return result;
+      let filePath;
+      try {
+        filePath = fileURLToPath2(url);
+      } catch {
+        return result;
+      }
+      if (!isApplicationSource(filePath, {
+        includeBuildOutput: true,
+        excludedRoots: options.excludedRoots
+      }))
+        return result;
+      const source = sourceText(result.source);
+      if (source === void 0) return result;
+      try {
+        const transformed = transformSource(source, {
+          filePath,
+          mapLocation: createSourceMapLocationMapper(filePath, source)
+        });
+        if (!transformed) return result;
+        recordInstrumentationManifestDelta(filePath, transformed.delta);
+        if (debug) console.info(`[rasputin] instrumented ${filePath}`);
+        return { ...result, source: transformed.code };
+      } catch {
+        return result;
+      }
+    }
+  });
+};
+
+// src/auto-instrumentation/sdk-source-boundary.ts
+import { dirname as dirname2, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var sdkPackageScopeRootFrom = (instrumentEntryUrl) => resolve6(dirname2(fileURLToPath3(instrumentEntryUrl)), "../../..");
+
+// src/instrument/node.ts
+registerRasputinNodeHooks({
+  excludedRoots: [sdkPackageScopeRootFrom(import.meta.url)]
+});

package/dist/rasputin-init.d.ts

@@ -1,4 +1,22 @@
-import { type RasputinClient, type RasputinOptions } from '@rasputin-ai/core';
+/**
+ * Node/Bun composition root for error transport, process handlers, and the bounded execution
+ * recorder. Centralizing this wiring keeps initialization fail-safe and ensures every capture path
+ * attaches runtime state using the same limits and lifecycle rules.
+ */
+import { type RasputinClient, type RasputinClientStats, type RasputinOptions } from '@rasputin-ai/core';
+import { type ExecutionRecorderOptions, type ExecutionRecorderStats, type RasputinExecution } from './execution-recorder';
+export type RasputinNodeOptions = RasputinOptions & {
+    /** Bounded runtime-state capture. Enabled by default; successful executions are discarded. */
+    executionRecorder?: ExecutionRecorderOptions;
+};
+export type RasputinNodeClientStats = RasputinClientStats & {
+    /** Process-local recorder safety, truncation, and memory-pressure counters. */
+    recorder: ExecutionRecorderStats;
+};
+export type RasputinNodeClient = Omit<RasputinClient, 'getStats'> & {
+    execution: RasputinExecution;
+    getStats: () => RasputinNodeClientStats;
+};
 /**
  * Boot the Node/Bun SDK: client + process global handlers.
  * Call once at process start. Never throws into the host app.
@@ -6,10 +24,11 @@ import { type RasputinClient, type RasputinOptions } from '@rasputin-ai/core';
  * @example
  * RasputinInit({
  *   projectApiKey: process.env.RASPUTIN_PROJECT_API_KEY!,
+ *   release: process.env.RASPUTIN_RELEASE!,
  *   environment: process.env.NODE_ENV ?? 'development',
- *   release: process.env.RASPUTIN_RELEASE,
+ *   enabled: ['staging', 'production'].includes(process.env.NODE_ENV ?? 'development'),
  *   moduleUrl: import.meta.url,
  * });
  */
-export declare const RasputinInit: (options: RasputinOptions) => RasputinClient;
+export declare const RasputinInit: (options: RasputinNodeOptions) => RasputinNodeClient;
 //# sourceMappingURL=rasputin-init.d.ts.map

package/dist/rasputin-init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rasputin-init.d.ts","sourceRoot":"","sources":["../src/rasputin-init.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,MAAM,mBAAmB,CAAC;AAI3B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,eAAe,KAAG,cAUvD,CAAC"}
+{"version":3,"file":"rasputin-init.d.ts","sourceRoot":"","sources":["../src/rasputin-init.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAIN,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EAEpB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAEN,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,MAAM,sBAAsB,CAAC;AAK9B,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG;IACnD,8FAA8F;IAC9F,iBAAiB,CAAC,EAAE,wBAAwB,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,mBAAmB,GAAG;IAC3D,+EAA+E;IAC/E,QAAQ,EAAE,sBAAsB,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,GAAG;IACnE,SAAS,EAAE,iBAAiB,CAAC;IAC7B,QAAQ,EAAE,MAAM,uBAAuB,CAAC;CACxC,CAAC;AAkDF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,mBAAmB,KAAG,kBA4C3D,CAAC"}

package/dist/sdk-meta.d.ts

@@ -1,4 +1,4 @@
 /** Generated by packages/sdk/scripts/generate-sdk-meta.ts — do not edit. */
 export declare const SDK_NAME = "@rasputin-ai/node";
-export declare const SDK_VERSION = "0.2.0";
+export declare const SDK_VERSION = "0.3.0";
 //# sourceMappingURL=sdk-meta.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rasputin-ai/node",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Official Rasputin AI SDK for Node and Bun.",
 	"type": "module",
 	"exports": {
@@ -8,6 +8,16 @@
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
+		},
+		"./instrument/bun": {
+			"types": "./dist/instrument/bun.d.ts",
+			"import": "./dist/instrument/bun.js",
+			"default": "./dist/instrument/bun.js"
+		},
+		"./instrument/node": {
+			"types": "./dist/instrument/node.d.ts",
+			"import": "./dist/instrument/node.js",
+			"default": "./dist/instrument/node.js"
 		}
 	},
 	"files": [
@@ -25,13 +35,14 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@rasputin-ai/core": "0.2.0"
+		"@jridgewell/trace-mapping": "0.3.31",
+		"@rasputin-ai/core": "0.3.0",
+		"typescript": "5"
 	},
 	"devDependencies": {
 		"@rasputin-ai/core": "workspace:*",
 		"@types/bun": "latest",
 		"@types/node": "22.13.10",
-		"esbuild": "0.25.12",
-		"typescript": "5"
+		"esbuild": "0.25.12"
 	}
 }