gorsee 0.2.3 → 0.2.5

package/dist-pkg/plugins/tailwind.d.ts

@@ -0,0 +1,15 @@
+import type { GorseePlugin } from "./index.js";
+export interface TailwindPluginConfig {
+    configPath?: string;
+    inputCSS?: string;
+    outputCSS?: string;
+}
+/** Generates tailwind.config.ts content */
+export declare function generateTailwindConfig(options?: {
+    content?: string[];
+    theme?: Record<string, unknown>;
+}): string;
+/** Generates base CSS with @tailwind directives */
+export declare function generateTailwindCSS(): string;
+/** Creates a Tailwind CSS integration plugin */
+export declare function tailwindPlugin(config?: TailwindPluginConfig): GorseePlugin;

package/dist-pkg/plugins/tailwind.js

@@ -0,0 +1,58 @@
+import { defineBuildPlugin } from "../build/plugin.js";
+import { definePlugin } from "./index.js";
+export function generateTailwindConfig(options) {
+  const content = options?.content ?? [
+    "./routes/**/*.{tsx,ts}",
+    "./components/**/*.{tsx,ts}"
+  ], themeStr = options?.theme ? JSON.stringify(options.theme, null, 4) : "{}";
+  return `/** @type {import('tailwindcss').Config} */
+export default {
+  content: ${JSON.stringify(content, null, 4)},
+  theme: {
+    extend: ${themeStr},
+  },
+  plugins: [],
+}
+`;
+}
+export function generateTailwindCSS() {
+  return `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+}
+export function tailwindPlugin(config = {}) {
+  const inputCSS = config.inputCSS ?? "./styles/globals.css", outputCSS = config.outputCSS ?? "./.gorsee/client/tailwind.css";
+  return definePlugin({
+    name: "gorsee-tailwind",
+    capabilities: ["styling"],
+    async setup() {
+      const configPath = config.configPath ?? "./tailwind.config.ts";
+      if (!await Bun.file(configPath).exists())
+        await Bun.write(configPath, generateTailwindConfig());
+    },
+    buildPlugins() {
+      return [
+        defineBuildPlugin({
+          name: "gorsee-tailwind-transform",
+          bun: {
+            name: "gorsee-tailwind-transform",
+            setup(build) {
+              build.onLoad({ filter: /\.css$/ }, async (args) => {
+                const source = await Bun.file(args.path).text();
+                if (source.includes("@tailwind"))
+                  try {
+                    await Bun.spawn(["bunx", "tailwindcss", "-i", args.path, "-o", outputCSS, "--minify"], { stdin: "inherit", stdout: "pipe", stderr: "pipe" }).exited;
+                    return { contents: await Bun.file(outputCSS).text(), loader: "css" };
+                  } catch {
+                    return { contents: source, loader: "css" };
+                  }
+                return;
+              });
+            }
+          }
+        })
+      ];
+    }
+  });
+}

package/dist-pkg/prod.d.ts

@@ -0,0 +1,21 @@
+import type { MiddlewareFn } from "./server/middleware.js";
+import { type RuntimeOptions } from "./runtime/project.js";
+import { type AIObservabilityConfig } from "./ai/index.js";
+interface StartProductionServerOptions extends RuntimeOptions {
+    port?: number;
+    registerSignalHandlers?: boolean;
+    rpcMiddlewares?: MiddlewareFn[];
+    ai?: AIObservabilityConfig;
+}
+export interface NodeProductionServer {
+    port: number;
+    stop(): Promise<void>;
+}
+export declare function startProductionServer(options?: StartProductionServerOptions): Promise<Bun.Server<undefined>>;
+export declare function startNodeProductionServer(options?: StartProductionServerOptions): Promise<NodeProductionServer>;
+export declare function createProductionFetchHandler(options?: Pick<StartProductionServerOptions, "cwd" | "env" | "rpcMiddlewares" | "ai" | "pathOverrides">): Promise<(request: Request, server?: {
+    requestIP(request: Request): {
+        address: string;
+    } | null;
+}) => Promise<Response>>;
+export {};

package/dist-pkg/prod.js

@@ -0,0 +1,347 @@
+import { createRouter, matchRoute, buildStaticMap } from "./router/index.js";
+import { securityHeaders } from "./security/headers.js";
+import { createRateLimiter } from "./security/rate-limit.js";
+import { compress } from "./server/compress.js";
+import { log, setLogLevel } from "./log/index.js";
+import { loadEnv } from "./env/index.js";
+import { generateNonce, wrapHTML } from "./server/html-shell.js";
+import { renderNotFoundPage } from "./server/not-found.js";
+import { createRateLimitResponse, handleRPCWithHeaders } from "./server/request-preflight.js";
+import {
+  createClientScriptPath
+} from "./server/page-render.js";
+import { createRequestSecurityPolicy } from "./server/request-security-policy.js";
+import {
+  renderRoutePageResponse,
+  renderRoutePartialResponse
+} from "./server/route-response.js";
+import { handleRouteRequest } from "./server/route-request.js";
+import { dispatchRuntimeRequestPlan } from "./server/runtime-dispatch.js";
+import { createRuntimeRequestPlan } from "./server/request-surface.js";
+import { servePrefixedStaticFile, serveStaticFile } from "./server/static-file.js";
+import {
+  BUILD_MANIFEST_SCHEMA_VERSION,
+  getClientBundleForRoute,
+  getPrerenderedHtmlPath,
+  isPrerenderedRoute,
+  loadBuildManifest
+} from "./server/manifest.js";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { createProjectContext, resolveRuntimeEnv } from "./runtime/project.js";
+import {
+  loadAppConfig,
+  resolveAIConfig,
+  resolveRPCMiddlewares,
+  resolveTrustedHosts,
+  resolveTrustedForwardedHops,
+  resolveTrustedOrigin,
+  resolveTrustForwardedHeaders
+} from "./runtime/app-config.js";
+import {
+  configureAIObservability,
+  createTraceIds,
+  emitAIEvent
+} from "./ai/index.js";
+function requireTrustedOrigin(trustedOrigin) {
+  if (!trustedOrigin)
+    throw Error("Missing trusted origin for production runtime. Set security.origin in app.config.ts or APP_ORIGIN in the environment.");
+  return trustedOrigin;
+}
+async function tryServeStatic(pathname, request, publicDir, clientDir, secHeaders) {
+  if (pathname === "/")
+    return null;
+  const bundleResponse = await servePrefixedStaticFile(pathname, "/_gorsee/", clientDir, {
+    contentType: "application/javascript",
+    cacheControl: "public, max-age=31536000, immutable",
+    extraHeaders: secHeaders
+  });
+  if (bundleResponse)
+    return bundleResponse;
+  return serveStaticFile(publicDir, pathname.slice(1), {
+    request,
+    etag: !0,
+    cacheControl: "public, max-age=3600",
+    extraHeaders: secHeaders
+  });
+}
+async function tryServePrerenderedPage(pathname, request, manifest, distDir, secHeaders) {
+  if (request.method !== "GET")
+    return null;
+  if (!isPrerenderedRoute(manifest, pathname))
+    return null;
+  return serveStaticFile(join(distDir, "static"), getPrerenderedHtmlPath(pathname), {
+    request,
+    etag: !0,
+    cacheControl: "public, max-age=3600",
+    contentType: "text/html; charset=utf-8",
+    extraHeaders: secHeaders
+  });
+}
+export async function startProductionServer(options = {}) {
+  const runtime = createProjectContext(options), registerSignalHandlers = options.registerSignalHandlers ?? !0;
+  await loadEnv(runtime.cwd);
+  const envConfig = resolveRuntimeEnv(process.env), port = options.port ?? envConfig.port, fetchHandler = await createProductionFetchHandler({
+    cwd: runtime.cwd,
+    env: process.env,
+    rpcMiddlewares: options.rpcMiddlewares,
+    ai: options.ai,
+    pathOverrides: options.pathOverrides
+  });
+  log.info("production server starting", { cwd: runtime.cwd });
+  const server = Bun.serve({
+    port,
+    fetch: fetchHandler
+  });
+  log.info("production server started", { url: `http://localhost:${server.port}` });
+  if (registerSignalHandlers) {
+    const shutdown = () => {
+      log.info("shutting down...");
+      server.stop(!0);
+      process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+  }
+  return server;
+}
+export async function startNodeProductionServer(options = {}) {
+  const runtime = createProjectContext(options), registerSignalHandlers = options.registerSignalHandlers ?? !0;
+  await loadEnv(runtime.cwd);
+  const envConfig = resolveRuntimeEnv(process.env), port = options.port ?? envConfig.port, fetchHandler = await createProductionFetchHandler({
+    cwd: runtime.cwd,
+    env: process.env,
+    rpcMiddlewares: options.rpcMiddlewares,
+    ai: options.ai,
+    pathOverrides: options.pathOverrides
+  });
+  log.info("node production server starting", { cwd: runtime.cwd });
+  const server = createServer(async (req, res) => {
+    try {
+      const request = createNodeRequest(req), response = await fetchHandler(request, {
+        requestIP(input) {
+          const address = req.socket.remoteAddress;
+          return address ? { address } : null;
+        }
+      });
+      await writeNodeResponse(res, response);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log.error("node production request failed", { error: message });
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      }
+      res.end("Internal Server Error");
+    }
+  });
+  await new Promise((resolve) => {
+    server.listen(port, resolve);
+  });
+  const address = server.address(), resolvedPort = typeof address === "object" && address ? address.port : port;
+  log.info("node production server started", { url: `http://localhost:${resolvedPort}` });
+  if (registerSignalHandlers) {
+    const shutdown = () => {
+      log.info("shutting down node server...");
+      new Promise((resolve) => server.close(() => resolve())).finally(() => process.exit(0));
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+  }
+  return {
+    port: resolvedPort,
+    stop() {
+      return new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+      });
+    }
+  };
+}
+export async function createProductionFetchHandler(options = {}) {
+  const state = await loadProductionRuntimeState(options), appConfig = await loadAppConfig(state.cwd, state.appConfigFile), rpcMiddlewares = resolveRPCMiddlewares(appConfig, options.rpcMiddlewares), trustedOrigin = requireTrustedOrigin(resolveTrustedOrigin(appConfig, options.env ?? process.env)), trustForwardedHeaders = resolveTrustForwardedHeaders(appConfig), trustedForwardedHops = resolveTrustedForwardedHops(appConfig), requestSecurityPolicy = createRequestSecurityPolicy({
+    trustedOrigin,
+    trustForwardedHeaders,
+    trustedForwardedHops,
+    trustedHosts: resolveTrustedHosts(appConfig)
+  });
+  configureAIObservability(resolveAIConfig(state.cwd, appConfig, options.ai));
+  return async (request, server) => {
+    const pathname = new URL(request.url).pathname, trace = createTraceIds(), startTs = performance.now();
+    await emitAIEvent({
+      kind: "request.start",
+      severity: "info",
+      source: "runtime",
+      message: "incoming production request",
+      requestId: trace.requestId,
+      traceId: trace.traceId,
+      spanId: trace.spanId,
+      data: { method: request.method, pathname }
+    });
+    const ip = server?.requestIP(request)?.address ?? "unknown", rateLimitResponse = await createRateLimitResponse(state.rateLimiter, ip);
+    if (rateLimitResponse)
+      return rateLimitResponse;
+    const nonce = generateNonce(), secHeaders = securityHeaders({}, nonce), match = matchRoute(state.routes, pathname, state.staticMap), requestPlan = createRuntimeRequestPlan({
+      pathname,
+      hasRouteMatch: Boolean(match),
+      allowPrerendered: !0
+    }), dispatch = await dispatchRuntimeRequestPlan({
+      plan: requestPlan.filter((surface) => surface !== "hmr"),
+      pathname,
+      request,
+      trace,
+      startTs,
+      source: "runtime",
+      route: match?.route.path,
+      handlers: {
+        rpc: async () => handleRPCWithHeaders(request, secHeaders, {
+          middlewares: rpcMiddlewares,
+          securityPolicy: requestSecurityPolicy
+        }),
+        bundle: async () => tryServeStatic(pathname, request, state.publicDir, state.clientDir, secHeaders),
+        static: async () => tryServeStatic(pathname, request, state.publicDir, state.clientDir, secHeaders),
+        prerendered: async () => tryServePrerenderedPage(pathname, request, state.manifest, state.distDir, secHeaders),
+        route: async () => {
+          if (!match)
+            return null;
+          await emitAIEvent({
+            kind: "route.match",
+            severity: "info",
+            source: "runtime",
+            message: "route matched",
+            requestId: trace.requestId,
+            traceId: trace.traceId,
+            spanId: trace.spanId,
+            route: match.route.path,
+            data: { pathname, file: match.route.filePath }
+          });
+          try {
+            return await handleRouteRequest({
+              match,
+              request,
+              trace,
+              extraMiddlewares: [state.compressMiddleware],
+              trustedOrigin,
+              trustForwardedHeaders,
+              securityPolicy: requestSecurityPolicy,
+              onPartialRequest: async ({ ctx, resolved }) => {
+                const clientScript = createClientScriptPath(getClientBundleForRoute(state.manifest, match.route.path));
+                return renderRoutePartialResponse({
+                  match,
+                  ctx,
+                  resolved,
+                  clientScript,
+                  secHeaders
+                });
+              },
+              onPageRequest: async ({ ctx, resolved }) => {
+                const clientScript = createClientScriptPath(getClientBundleForRoute(state.manifest, match.route.path));
+                return renderRoutePageResponse({
+                  match,
+                  ctx,
+                  resolved,
+                  clientScript,
+                  nonce,
+                  secHeaders,
+                  wrapHTML
+                });
+              }
+            });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log.error("request error", { path: pathname, error: message });
+            await emitAIEvent({
+              kind: "request.error",
+              severity: "error",
+              source: "runtime",
+              message,
+              requestId: trace.requestId,
+              traceId: trace.traceId,
+              spanId: trace.spanId,
+              route: match.route.path,
+              durationMs: Number((performance.now() - startTs).toFixed(2)),
+              data: { method: request.method, pathname, error: message }
+            });
+            return new Response(wrapHTML("<h1>500</h1><p>Internal Server Error</p>", nonce), {
+              status: 500,
+              headers: { "Content-Type": "text/html", ...secHeaders }
+            });
+          }
+        },
+        "not-found": async () => new Response(await renderNotFoundPage(state.routesDir, nonce), {
+          status: 404,
+          headers: { "Content-Type": "text/html", ...secHeaders }
+        })
+      }
+    });
+    if (dispatch)
+      return dispatch.response;
+    throw Error(`Unhandled request plan for ${pathname}`);
+  };
+}
+async function loadProductionRuntimeState(options = {}) {
+  const runtime = createProjectContext(options);
+  await loadEnv(runtime.cwd);
+  const envConfig = resolveRuntimeEnv(process.env);
+  setLogLevel(envConfig.logLevel);
+  const manifest = await loadBuildManifest(runtime.paths.distDir);
+  log.info("loaded manifest", {
+    routes: Object.keys(manifest.routes).length,
+    built: manifest.buildTime,
+    schemaVersion: manifest.schemaVersion,
+    expectedSchemaVersion: BUILD_MANIFEST_SCHEMA_VERSION
+  });
+  const routes = await createRouter(runtime.paths.routesDir), staticMap = buildStaticMap(routes), rateLimiter = createRateLimiter(envConfig.rateLimit, envConfig.rateWindow);
+  return {
+    cwd: runtime.cwd,
+    routesDir: runtime.paths.routesDir,
+    publicDir: runtime.paths.publicDir,
+    distDir: runtime.paths.distDir,
+    clientDir: runtime.paths.clientDir,
+    appConfigFile: runtime.paths.appConfigFile,
+    manifest,
+    routes,
+    staticMap,
+    rateLimiter,
+    compressMiddleware: compress()
+  };
+}
+function createNodeRequest(req) {
+  const headers = new Headers;
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        headers.append(key, item);
+      continue;
+    }
+    if (typeof value === "string")
+      headers.set(key, value);
+  }
+  const host = headers.get("host") ?? "127.0.0.1", url = new URL(req.url ?? "/", `http://${host}`), method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD")
+    return new Request(url, { method, headers });
+  return new Request(url, {
+    method,
+    headers,
+    body: Readable.toWeb(req),
+    duplex: "half"
+  });
+}
+async function writeNodeResponse(res, response) {
+  res.statusCode = response.status;
+  res.statusMessage = response.statusText;
+  const setCookie = response.headers.getSetCookie?.() ?? [];
+  if (setCookie.length > 0)
+    res.setHeader("Set-Cookie", setCookie);
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie" && setCookie.length > 0)
+      return;
+    res.setHeader(key, value);
+  });
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  const body = Buffer.from(await response.arrayBuffer());
+  res.end(body);
+}

package/dist-pkg/reactive/computed.d.ts

@@ -0,0 +1,3 @@
+import { type ReactiveDiagnosticOptions } from "./diagnostics.js";
+export type ComputedGetter<T> = () => T;
+export declare function createComputed<T>(fn: () => T, options?: ReactiveDiagnosticOptions): ComputedGetter<T>;

package/dist-pkg/reactive/computed.js

@@ -0,0 +1,15 @@
+import { computed as alienComputed } from "alien-signals";
+import {
+  runTrackedComputation,
+  trackComputedCreated,
+  trackComputedRead
+} from "./diagnostics.js";
+import { GORSEE_SIGNAL_MARKER } from "../runtime/html-escape.js";
+export function createComputed(fn, options = {}) {
+  const nodeId = trackComputedCreated(options.label), computed = alienComputed(() => runTrackedComputation(nodeId, "computed", options.label, fn)), getter = () => {
+    trackComputedRead(nodeId, options.label);
+    return computed();
+  };
+  getter[GORSEE_SIGNAL_MARKER] = !0;
+  return getter;
+}

package/dist-pkg/reactive/data.d.ts

@@ -0,0 +1,25 @@
+import { type Mutation, type MutationOptions } from "./optimistic.js";
+import { type ResourceOptions } from "./resource.js";
+import type { SignalGetter } from "./signal.js";
+export interface DataQueryOptions<T> extends Omit<ResourceOptions, "key"> {
+    key: string;
+    queryFn: () => Promise<T>;
+}
+export interface DataQuery<T> {
+    key: string;
+    data: SignalGetter<T | undefined>;
+    loading: SignalGetter<boolean>;
+    error: SignalGetter<Error | undefined>;
+    refetch: () => void;
+    setData: (value: T | undefined | ((prev: T | undefined) => T | undefined)) => void;
+    invalidate: () => void;
+}
+export interface DataMutationOptions<T, V> extends MutationOptions<T, V> {
+    invalidate?: string[] | ((data: T, variables: V) => string[] | "all");
+}
+export interface DataMutation<T, V> extends Mutation<T, V> {
+    optimisticQuery: <S>(query: Pick<DataQuery<S>, "data" | "setData">, update: (current: S | undefined, variables: V) => S, variables: V) => Promise<T>;
+    invalidateQueries: (keys?: string[] | "all") => void;
+}
+export declare function createDataQuery<T>(options: DataQueryOptions<T>): DataQuery<T>;
+export declare function createDataMutation<T, V = void>(options: DataMutationOptions<T, V>): DataMutation<T, V>;

package/dist-pkg/reactive/data.js

@@ -0,0 +1,56 @@
+import { createMutation } from "./optimistic.js";
+import {
+  createResource,
+  invalidateAll,
+  invalidateResource
+} from "./resource.js";
+export function createDataQuery(options) {
+  const [data, state] = createResource(options.queryFn, {
+    ...options,
+    key: options.key
+  });
+  return {
+    key: options.key,
+    data,
+    loading: state.loading,
+    error: state.error,
+    refetch: state.refetch,
+    setData: state.mutate,
+    invalidate() {
+      invalidateResource(options.key);
+    }
+  };
+}
+export function createDataMutation(options) {
+  let lastInvalidatedKeys;
+  const mutation = createMutation({
+    ...options,
+    onSuccess(data, variables) {
+      lastInvalidatedKeys = resolveInvalidationTargets(options.invalidate, data, variables);
+      applyInvalidationTargets(lastInvalidatedKeys);
+      options.onSuccess?.(data, variables);
+    }
+  });
+  return {
+    ...mutation,
+    async optimisticQuery(query, update, variables) {
+      return mutation.optimistic(query.data, (value) => query.setData(() => value), update, variables);
+    },
+    invalidateQueries(keys = lastInvalidatedKeys ?? []) {
+      applyInvalidationTargets(keys);
+    }
+  };
+}
+function resolveInvalidationTargets(invalidate, data, variables) {
+  if (typeof invalidate === "function")
+    return invalidate(data, variables);
+  return invalidate ?? [];
+}
+function applyInvalidationTargets(keys) {
+  if (keys === "all") {
+    invalidateAll();
+    return;
+  }
+  for (const key of keys)
+    invalidateResource(key);
+}

package/dist-pkg/reactive/diagnostics.d.ts

@@ -0,0 +1,100 @@
+export declare const REACTIVE_TRACE_SCHEMA_VERSION = 1;
+type ReactiveNodeKind = "signal" | "computed" | "effect" | "resource" | "mutation";
+type ReactiveInvalidationReason = "write" | "resource.invalidate" | "resource.invalidateAll";
+export interface ReactiveDiagnosticsSnapshot {
+    signalsCreated: number;
+    signalReads: number;
+    signalWrites: number;
+    computedCreated: number;
+    computedReads: number;
+    computedRuns: number;
+    effectCreated: number;
+    effectRuns: number;
+    resourcesCreated: number;
+    resourceLoadsStarted: number;
+    resourceLoadsSucceeded: number;
+    resourceLoadsFailed: number;
+    resourceInvalidations: number;
+    resourceMutations: number;
+    mutationsCreated: number;
+    mutationRuns: number;
+    mutationSuccesses: number;
+    mutationFailures: number;
+    mutationRollbacks: number;
+    mutationResets: number;
+}
+export interface ReactiveDiagnosticsConfig {
+    enabled?: boolean;
+    captureEvents?: boolean;
+    maxEvents?: number;
+}
+export interface ReactiveDiagnosticOptions {
+    label?: string;
+}
+export interface ReactiveGraphNode {
+    id: number;
+    kind: ReactiveNodeKind;
+    label?: string;
+    reads: number;
+    writes: number;
+    runs: number;
+    invalidations: number;
+}
+export interface ReactiveDependencyEdge {
+    sourceNodeId: number;
+    targetNodeId: number;
+    sourceKind: ReactiveNodeKind;
+    targetKind: ReactiveNodeKind;
+    sourceLabel?: string;
+    targetLabel?: string;
+    reads: number;
+}
+export interface ReactiveDiagnosticEvent {
+    seq: number;
+    kind: "signal:create" | "signal:read" | "signal:write" | "computed:create" | "computed:read" | "computed:run" | "effect:create" | "effect:run" | "resource:create" | "resource:load.start" | "resource:load.success" | "resource:load.error" | "resource:refetch" | "resource:mutate" | "resource:invalidate" | "mutation:create" | "mutation:start" | "mutation:success" | "mutation:error" | "mutation:settled" | "mutation:rollback" | "mutation:reset" | "invalidation";
+    nodeId: number;
+    label?: string;
+    relatedNodeId?: number;
+    relatedLabel?: string;
+    reason?: ReactiveInvalidationReason;
+    causeNodeIds?: number[];
+    causeLabels?: string[];
+    cacheKey?: string;
+    detail?: string;
+}
+export interface ReactiveTraceArtifact {
+    schemaVersion: typeof REACTIVE_TRACE_SCHEMA_VERSION;
+    snapshot: ReactiveDiagnosticsSnapshot;
+    nodes: ReactiveGraphNode[];
+    edges: ReactiveDependencyEdge[];
+    events: ReactiveDiagnosticEvent[];
+}
+export declare function configureReactiveDiagnostics(config?: ReactiveDiagnosticsConfig): void;
+export declare function resetReactiveDiagnostics(): void;
+export declare function getReactiveDiagnosticsSnapshot(): ReactiveDiagnosticsSnapshot;
+export declare function getReactiveGraphNodes(): ReactiveGraphNode[];
+export declare function getReactiveDependencyEdges(): ReactiveDependencyEdge[];
+export declare function getReactiveDiagnosticsEvents(): ReactiveDiagnosticEvent[];
+export declare function getReactiveTraceArtifact(): ReactiveTraceArtifact;
+export declare function trackSignalCreated(label?: string): number | null;
+export declare function trackSignalRead(nodeId?: number | null, label?: string): void;
+export declare function trackSignalWrite(nodeId?: number | null, label?: string): void;
+export declare function trackComputedCreated(label?: string): number | null;
+export declare function trackComputedRead(nodeId?: number | null, label?: string): void;
+export declare function trackEffectCreated(label?: string): number | null;
+export declare function trackResourceCreated(label?: string, cacheKey?: string): number | null;
+export declare function trackResourceLoadStart(nodeId?: number | null, label?: string, cacheKey?: string, detail?: string): void;
+export declare function trackResourceLoadSuccess(nodeId?: number | null, label?: string, cacheKey?: string): void;
+export declare function trackResourceLoadError(nodeId?: number | null, label?: string, cacheKey?: string, detail?: string): void;
+export declare function trackResourceRefetch(nodeId?: number | null, label?: string, cacheKey?: string): void;
+export declare function trackResourceMutate(nodeId?: number | null, label?: string, cacheKey?: string): void;
+export declare function trackResourceInvalidation(cacheKey: string, reason: ReactiveInvalidationReason): void;
+export declare function trackMutationCreated(label?: string): number | null;
+export declare function trackMutationStart(nodeId?: number | null, label?: string): void;
+export declare function trackMutationSuccess(nodeId?: number | null, label?: string): void;
+export declare function trackMutationError(nodeId?: number | null, label?: string, detail?: string): void;
+export declare function trackMutationSettled(nodeId?: number | null, label?: string): void;
+export declare function trackMutationRollback(nodeId?: number | null, label?: string): void;
+export declare function trackMutationReset(nodeId?: number | null, label?: string): void;
+export declare function runTrackedComputation<T>(nodeId: number | null | undefined, kind: "computed" | "effect", label: string | undefined, fn: () => T): T;
+export {};