tidewave 0.3.0 → 0.5.0

package/dist/core.d.ts

@@ -72,6 +72,11 @@ export declare function createExtractError(code: ExtractError['error']['code'],
 export interface TidewaveConfig {
     port?: number;
     host?: string;
+    clientUrl?: string;
     allowRemoteAccess?: boolean;
     allowedOrigins?: string[];
+    team?: {
+        id?: string;
+        token?: string;
+    };
 }

package/dist/evaluation/eval_worker.js

@@ -1,32 +1,3 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
 // src/evaluation/eval_worker.ts
 process.on("message", async ({ code, args }) => {
   if (!process.send) {
@@ -40,7 +11,7 @@ process.on("message", async ({ code, args }) => {
     process.send({
       type: "result",
       success: true,
-      data: (result || null) && result
+      data: (result ?? null) && result
     });
   } catch (error) {
     process.send({

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { extractDocs, getSourceLocation, formatOutput } from './resolution';
-import { executeIsolated } from './evaluation/code_executor';
+import type { EvaluatedModuleResult, EvaluationRequest } from './core';
 export declare const Tidewave: {
     extractDocs: typeof extractDocs;
     getSourceLocation: typeof getSourceLocation;
     formatOutput: typeof formatOutput;
-    executeIsolated: typeof executeIsolated;
+    executeIsolated(request: EvaluationRequest): Promise<EvaluatedModuleResult>;
 };

package/dist/logger/circular-buffer.d.ts

@@ -0,0 +1,54 @@
+export interface StoredLogRecord {
+    timestamp: string;
+    severityText: string;
+    body: string;
+    attributes?: Record<string, any>;
+    resource?: Record<string, any>;
+}
+export interface LogFilterOptions {
+    tail?: number;
+    grep?: string;
+    level?: string;
+    since?: string;
+}
+/**
+ * Standalone circular buffer for storing logs.
+ * This is a global singleton that is not tied to any logger or exporter.
+ * Both console.log patches and OpenTelemetry processors write directly to this buffer.
+ */
+export declare class CircularBuffer {
+    private buffer;
+    private maxSize;
+    private writeIndex;
+    private count;
+    constructor(maxSize?: number);
+    /**
+     * Add a log entry to the circular buffer.
+     * This method is called directly by console patching and OTel processors.
+     */
+    addLog(log: StoredLogRecord): void;
+    /**
+     * Get logs from the buffer with optional filtering.
+     */
+    getLogs(options?: LogFilterOptions): StoredLogRecord[];
+    /**
+     * Get all logs in chronological order.
+     */
+    private getAllLogs;
+    /**
+     * Get statistics about the buffer usage.
+     */
+    getStats(): {
+        totalLogs: number;
+        bufferSize: number;
+        bufferUsage: string;
+    };
+    /**
+     * Clear the buffer.
+     */
+    clear(): void;
+}
+declare global {
+    var __tidewaveCircularBuffer: CircularBuffer | undefined;
+}
+export declare const circularBuffer: CircularBuffer;

package/dist/logger/instrumentation.d.ts

@@ -0,0 +1,2 @@
+export { TidewaveSpanProcessor } from './tidewave-span-processor';
+export { TidewaveLogRecordProcessor } from './tidewave-log-record-processor';

package/dist/logger/tidewave-log-record-processor.d.ts

@@ -0,0 +1,17 @@
+import type { LogRecordProcessor, SdkLogRecord } from '@opentelemetry/sdk-logs';
+import type { Context } from '@opentelemetry/api';
+/**
+ * Custom LogRecordProcessor that captures OpenTelemetry logger logs
+ * and writes them directly to the circular buffer.
+ *
+ * This is opt-in for users who want to capture actual logger logs
+ * (not console.log, which is handled separately by console patching).
+ */
+export declare class TidewaveLogRecordProcessor implements LogRecordProcessor {
+    /**
+     * Called when a log record is emitted.
+     */
+    onEmit(logRecord: SdkLogRecord, _context?: Context): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/logger/tidewave-span-processor.d.ts

@@ -0,0 +1,26 @@
+import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import type { Span, Context } from '@opentelemetry/api';
+/**
+ * Custom SpanProcessor that converts OpenTelemetry spans to logs and writes them
+ * directly to the circular buffer.
+ * This is used to capture Next.js HTTP request/response spans and
+ * make them available via the get_logs tool.
+ */
+export declare class TidewaveSpanProcessor implements SpanProcessor {
+    /**
+     * Called when a span is started. We don't need to do anything here.
+     */
+    onStart(_span: Span, _parentContext: Context): void;
+    /**
+     * Called when a span ends. This is where we convert the span to a log entry
+     * and write it directly to the circular buffer.
+     */
+    onEnd(span: ReadableSpan): void;
+    /**
+     * Calculate span duration in milliseconds from high-resolution time
+     */
+    private calculateDuration;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/{next-js.d.ts → next-js/handler.d.ts}

@@ -1,15 +1,11 @@
 import type { NextApiRequest, NextApiResponse } from 'next';
-import { NextResponse, type NextRequest } from 'next/server';
-import { type Request, type Response } from './http';
-import type { TidewaveConfig } from './core';
+import { type Request, type Response } from '../http';
+import type { TidewaveConfig } from '../core';
 type NextJsHandler = (_req: NextApiRequest, _res: NextApiResponse) => Promise<void>;
-type NextJsMiddleware = (_req: NextRequest) => Promise<NextResponse>;
 type NextHandler = () => ValueOrPromise<unknown>;
 export type FunctionLike = (...args: any[]) => unknown;
 export type Nextable<H extends FunctionLike> = (...args: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
 export type ValueOrPromise<T> = T | Promise<T>;
 export type RequestHandler<Req extends Request, Res extends Response> = (req: Req, res: Res) => ValueOrPromise<void>;
 export declare function tidewaveHandler(config?: TidewaveConfig): Promise<NextJsHandler>;
-export declare function tidewaveMiddleware(): NextJsMiddleware;
-export declare function isTidewaveRoute(pathname: string): boolean;
 export {};