@timber-js/app 0.2.0-alpha.98 → 0.2.0-alpha.99

package/dist/plugins/dev-logs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-logs.d.ts","sourceRoot":"","sources":["../../src/plugins/dev-logs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,iDAAiD;AACjD,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAIzE,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,cAAc,CAAC;IACtB,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AA2ID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAsBnD;AAoDD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAiBzD"}

package/dist/plugins/dev-terminal-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-terminal-error.d.ts","sourceRoot":"","sources":["../../src/plugins/dev-terminal-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAKL,KAAK,UAAU,EAEhB,MAAM,wBAAwB,CAAC;AA4GhC;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAkEhG"}

package/dist/server/deny-page-resolver.d.ts

@@ -1,52 +0,0 @@
-/**
- * Deny Page Resolver — resolves status-code file components for in-tree deny handling.
- *
- * When AccessGate or PageDenyBoundary catches a DenySignal, they need to
- * render the matching deny page (403.tsx, 4xx.tsx, error.tsx) as a normal
- * element in the React tree. This module resolves the deny page chain from
- * the segment chain — a list of fallback components ordered by specificity.
- *
- * The chain is built during buildRouteElement and passed as a prop to
- * AccessGate and PageDenyBoundary. At catch time, the first matching
- * component is rendered.
- *
- * See design/10-error-handling.md §"Status-Code Files", TIM-666.
- */
-import type { ManifestSegmentNode } from './route-matcher.js';
-/** A single entry in the deny page fallback chain. */
-export interface DenyPageEntry {
-    /** Status code filter: specific (403), category (400 = any 4xx), or null (catch-all). */
-    status: number | null;
-    /** The component to render (server or client — both work). */
-    component: (...args: unknown[]) => unknown;
-}
-/**
- * Build the deny page fallback chain from the segment chain.
- *
- * Walks segments from `startIndex` outward (toward root) and collects
- * status-code file components in fallback order:
- * 1. Specific status files (403.tsx, 404.tsx) — exact match
- * 2. Category catch-alls (4xx.tsx) — matches any 4xx
- * 3. error.tsx — catches everything
- *
- * Each segment is checked in this order. The chain is ordered so the
- * FIRST match wins at catch time.
- */
-export declare function buildDenyPageChain(segments: ManifestSegmentNode[], startIndex: number): Promise<DenyPageEntry[]>;
-/**
- * Find the first deny page in the chain that matches the given status code.
- * Returns a React element for the matching component, or null if no match.
- */
-export declare function renderMatchingDenyPage(chain: DenyPageEntry[], status: number, data: unknown): React.ReactElement | null;
-/**
- * Set the deny status in the request context ALS.
- * Called from AccessGate / PageDenyBoundary when a DenySignal is caught.
- * The pipeline reads this after render to set the HTTP status code.
- */
-export declare function setDenyStatus(status: number): void;
-/**
- * Read the deny status from the request context ALS.
- * Returns undefined if no deny was caught during render.
- */
-export declare function getDenyStatus(): number | undefined;
-//# sourceMappingURL=deny-page-resolver.d.ts.map

package/dist/server/deny-page-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deny-page-resolver.d.ts","sourceRoot":"","sources":["../../src/server/deny-page-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAM9D,sDAAsD;AACtD,MAAM,WAAW,aAAa;IAC5B,yFAAyF;IACzF,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,8DAA8D;IAC9D,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CAC5C;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,EAAE,CAAC,CAqD1B;AAID;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,aAAa,EAAE,EACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,OAAO,GACZ,KAAK,CAAC,YAAY,GAAG,IAAI,CAkB3B;AAID;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAKlD;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,SAAS,CAElD"}

package/dist/server/dev-fetch-instrumentation.d.ts

@@ -1,22 +0,0 @@
-/**
- * Dev-mode fetch instrumentation — patches globalThis.fetch to create OTEL
- * spans for every fetch call, giving visibility into async data fetching
- * in the dev request log tree.
- *
- * Only activated in dev mode — zero overhead in production.
- *
- * The spans are automatically children of the active OTEL context (e.g. a
- * timber.page or timber.layout span), so they appear nested under the
- * component that initiated the fetch in the dev log tree.
- *
- * Design ref: 17-logging.md §"Dev Logging", LOCAL-289
- */
-export type DevFetchCleanup = () => void;
-/**
- * Patch globalThis.fetch to wrap every call in an OTEL span.
- *
- * Returns a cleanup function that restores the original fetch.
- * Only call this in dev mode.
- */
-export declare function instrumentDevFetch(): DevFetchCleanup;
-//# sourceMappingURL=dev-fetch-instrumentation.d.ts.map

package/dist/server/dev-fetch-instrumentation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-fetch-instrumentation.d.ts","sourceRoot":"","sources":["../../src/server/dev-fetch-instrumentation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC;AAEzC;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CA+CpD"}

package/dist/server/dev-holding-server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-holding-server.d.ts","sourceRoot":"","sources":["../../src/server/dev-holding-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEtC,kEAAkE;IAClE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AA8ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAmDnD"}

package/dist/server/dev-logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-logger.d.ts","sourceRoot":"","sources":["../../src/server/dev-logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAIlE,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3E,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAmMD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,UAAU,CAMnE;AAID;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,CAgDtF;AAyGD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM,CAc1F;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,MAAM,CA6BxD"}

package/dist/server/dev-span-processor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-span-processor.d.ts","sourceRoot":"","sources":["../../src/server/dev-span-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAEzB,qBAAa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,YAAY,CAAqC;IACzD,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,MAAM,EAAE,eAAe;IAKnC,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI;IAI7C,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAqB/B,OAAO,CAAC,MAAM;IAUR,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAGlC"}

package/dist/server/dev-warnings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dev-warnings.d.ts","sourceRoot":"","sources":["../../src/server/dev-warnings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAK1C,eAAO,MAAM,SAAS;;;;;;;CAOZ,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAInE,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AASD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAEhE;AA0CD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CASrE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAUpE;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CASxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAU5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAQnF;AAKD;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAQtF;AAID;;;GAGG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,WAAW,CAAC,MAAM,CAAC,CAEjD"}

package/dist/server/page-deny-boundary.d.ts

@@ -1,31 +0,0 @@
-/**
- * PageDenyBoundary — catches DenySignal from page components server-side.
- *
- * Wraps a server component page by calling it as an async function (the same
- * thing React Flight does internally). If the page throws DenySignal, the
- * boundary catches it and renders the matching deny page as a normal element.
- * No error reaches React Flight — the Flight stream is clean, SSR succeeds,
- * and the entire request uses a single renderToReadableStream call.
- *
- * Client component pages ('use client') are NOT wrapped — they can't call
- * deny() (server-only API) and must go through createElement normally.
- *
- * See design/04-authorization.md, design/10-error-handling.md, TIM-666.
- */
-import type { DenyPageEntry } from './deny-page-resolver.js';
-/**
- * Async server component that wraps a page call with DenySignal catching.
- *
- * Calls the page component as an async function, awaits it, and catches
- * DenySignal. On catch, renders the deny page in-tree. On success, returns
- * the page's rendered output normally.
- */
-export declare function PageDenyBoundary({ Page, route, denyPages, }: {
-    /** The page server component function. */
-    Page: (...args: unknown[]) => unknown;
-    /** Route path for OTEL tracing. */
-    route: string;
-    /** Deny page fallback chain from the segment chain. */
-    denyPages: DenyPageEntry[];
-}): Promise<React.ReactElement>;
-//# sourceMappingURL=page-deny-boundary.d.ts.map

package/dist/server/page-deny-boundary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"page-deny-boundary.d.ts","sourceRoot":"","sources":["../../src/server/page-deny-boundary.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAI7D;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,IAAI,EACJ,KAAK,EACL,SAAS,GACV,EAAE;IACD,0CAA0C;IAC1C,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACtC,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,SAAS,EAAE,aAAa,EAAE,CAAC;CAC5B,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAiB9B"}

package/src/server/dev-fetch-instrumentation.ts

@@ -1,96 +0,0 @@
-/**
- * Dev-mode fetch instrumentation — patches globalThis.fetch to create OTEL
- * spans for every fetch call, giving visibility into async data fetching
- * in the dev request log tree.
- *
- * Only activated in dev mode — zero overhead in production.
- *
- * The spans are automatically children of the active OTEL context (e.g. a
- * timber.page or timber.layout span), so they appear nested under the
- * component that initiated the fetch in the dev log tree.
- *
- * Design ref: 17-logging.md §"Dev Logging", LOCAL-289
- */
-
-import * as api from '@opentelemetry/api';
-
-export type DevFetchCleanup = () => void;
-
-/**
- * Patch globalThis.fetch to wrap every call in an OTEL span.
- *
- * Returns a cleanup function that restores the original fetch.
- * Only call this in dev mode.
- */
-export function instrumentDevFetch(): DevFetchCleanup {
-  const originalFetch = globalThis.fetch;
-  const tracer = api.trace.getTracer('timber.js');
-
-  globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const { method, url } = extractFetchInfo(input, init);
-
-    return tracer.startActiveSpan(
-      'timber.fetch',
-      {
-        attributes: {
-          'http.request.method': method,
-          'http.url': url,
-        },
-      },
-      async (span) => {
-        try {
-          const response = await originalFetch(input, init);
-
-          span.setAttribute('http.response.status_code', response.status);
-
-          // Surface cache status from standard headers
-          const cacheStatus =
-            response.headers.get('X-Cache') ?? response.headers.get('CF-Cache-Status');
-          if (cacheStatus) {
-            span.setAttribute('timber.cache_status', cacheStatus);
-          }
-
-          span.setStatus({ code: api.SpanStatusCode.OK });
-          span.end();
-          return response;
-        } catch (error) {
-          span.setStatus({ code: api.SpanStatusCode.ERROR });
-          if (error instanceof Error) {
-            span.setAttribute('timber.fetch_error', error.message);
-            span.recordException(error);
-          }
-          span.end();
-          throw error;
-        }
-      }
-    );
-  };
-
-  return () => {
-    globalThis.fetch = originalFetch;
-  };
-}
-
-/**
- * Extract method and URL from the various fetch() call signatures.
- */
-function extractFetchInfo(
-  input: RequestInfo | URL,
-  init?: RequestInit
-): { method: string; url: string } {
-  let method = init?.method ?? 'GET';
-  let url: string;
-
-  if (input instanceof Request) {
-    url = input.url;
-    if (!init?.method) {
-      method = input.method;
-    }
-  } else if (input instanceof URL) {
-    url = input.toString();
-  } else {
-    url = input;
-  }
-
-  return { method: method.toUpperCase(), url };
-}

package/src/server/dev-span-processor.ts

@@ -1,78 +0,0 @@
-/**
- * DevSpanProcessor — Custom OTEL SpanProcessor that drives dev log output.
- *
- * Collects completed spans per-request (correlated by trace ID). When the
- * root span (http.server.request) ends, all child spans are already collected
- * (child spans end before parent in OTEL). The processor formats the span
- * tree and writes it to stderr.
- *
- * This replaces the old DevLogEmitter/DevLogEvents system. OTEL spans are
- * now the single source of truth for dev logging — no more parallel event
- * systems that can drift.
- *
- * Design doc: 17-logging.md §"Dev Logging", 21-dev-server.md §"Dev Logging"
- */
-
-import type { SpanProcessor, ReadableSpan } from '@opentelemetry/sdk-trace-base';
-import type { Span, Context } from '@opentelemetry/api';
-import {
-  formatSpanTree,
-  formatSpanSummary,
-  formatJson,
-  type DevLogMode,
-  type DevLoggerConfig,
-} from './dev-logger.js';
-
-export class DevSpanProcessor implements SpanProcessor {
-  private spansByTrace = new Map<string, ReadableSpan[]>();
-  private mode: DevLogMode;
-  private config: DevLoggerConfig;
-
-  constructor(config: DevLoggerConfig) {
-    this.config = config;
-    this.mode = config.mode ?? 'tree';
-  }
-
-  onStart(_span: Span, _context: Context): void {
-    // No action needed on span start — we collect on end.
-  }
-
-  onEnd(span: ReadableSpan): void {
-    const traceId = span.spanContext().traceId;
-
-    let spans = this.spansByTrace.get(traceId);
-    if (!spans) {
-      spans = [];
-      this.spansByTrace.set(traceId, spans);
-    }
-    spans.push(span);
-
-    // Root span signals request completion — all child spans are already
-    // collected because OTEL ends child spans before parent spans.
-    if (span.name === 'http.server.request') {
-      const output = this.format(spans);
-      if (output) {
-        process.stderr.write(output);
-      }
-      this.spansByTrace.delete(traceId);
-    }
-  }
-
-  private format(spans: ReadableSpan[]): string {
-    if (this.mode === 'quiet') return '';
-    if (this.mode === 'json') return formatJson(spans);
-    if (this.mode === 'summary') return formatSpanSummary(spans, this.config);
-    // Both 'tree' and 'verbose' use the tree formatter.
-    // verbose will show additional detail (every component render) once
-    // component-level spans are wired.
-    return formatSpanTree(spans, this.config);
-  }
-
-  async shutdown(): Promise<void> {
-    this.spansByTrace.clear();
-  }
-
-  async forceFlush(): Promise<void> {
-    // Nothing to flush — output happens synchronously in onEnd.
-  }
-}

package/src/server/page-deny-boundary.tsx

@@ -1,56 +0,0 @@
-/**
- * PageDenyBoundary — catches DenySignal from page components server-side.
- *
- * Wraps a server component page by calling it as an async function (the same
- * thing React Flight does internally). If the page throws DenySignal, the
- * boundary catches it and renders the matching deny page as a normal element.
- * No error reaches React Flight — the Flight stream is clean, SSR succeeds,
- * and the entire request uses a single renderToReadableStream call.
- *
- * Client component pages ('use client') are NOT wrapped — they can't call
- * deny() (server-only API) and must go through createElement normally.
- *
- * See design/04-authorization.md, design/10-error-handling.md, TIM-666.
- */
-
-import { DenySignal } from './primitives.js';
-import type { DenyPageEntry } from './deny-page-resolver.js';
-import { renderMatchingDenyPage, setDenyStatus } from './deny-page-resolver.js';
-import { withSpan } from './tracing.js';
-
-/**
- * Async server component that wraps a page call with DenySignal catching.
- *
- * Calls the page component as an async function, awaits it, and catches
- * DenySignal. On catch, renders the deny page in-tree. On success, returns
- * the page's rendered output normally.
- */
-export async function PageDenyBoundary({
-  Page,
-  route,
-  denyPages,
-}: {
-  /** The page server component function. */
-  Page: (...args: unknown[]) => unknown;
-  /** Route path for OTEL tracing. */
-  route: string;
-  /** Deny page fallback chain from the segment chain. */
-  denyPages: DenyPageEntry[];
-}): Promise<React.ReactElement> {
-  try {
-    // Call the page as an async function — same as React Flight does.
-    // Wrap in OTEL span for tracing (replaces the TracedPage wrapper).
-    const result = await withSpan('timber.page', { 'timber.route': route }, () => Page({}));
-    return result as React.ReactElement;
-  } catch (error: unknown) {
-    if (error instanceof DenySignal) {
-      const denyElement = renderMatchingDenyPage(denyPages, error.status, error.data);
-      if (denyElement) {
-        setDenyStatus(error.status);
-        return denyElement;
-      }
-    }
-    // Non-deny errors (RedirectSignal, runtime errors) propagate normally.
-    throw error;
-  }
-}