@flight-framework/core 0.1.0 → 0.2.1

package/dist/rsc/plugins/esbuild.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @flight-framework/core - esbuild Plugin for RSC
+ *
+ * esbuild plugin for Flight Server Components.
+ * Transforms 'use client' and 'use server' directives at build time.
+ *
+ * Philosophy: Zero lock-in - esbuild is optional, user decides bundler.
+ *
+ * @module @flight-framework/core/rsc/plugins/esbuild
+ */
+/**
+ * esbuild Plugin interface (minimal)
+ * We define our own to avoid requiring esbuild as dependency
+ */
+interface EsbuildPlugin {
+    name: string;
+    setup: (build: EsbuildBuild) => void | Promise<void>;
+}
+interface EsbuildBuild {
+    initialOptions: EsbuildBuildOptions;
+    onStart: (callback: () => void | Promise<void>) => void;
+    onEnd: (callback: (result: EsbuildResult) => void | Promise<void>) => void;
+    onResolve: (options: {
+        filter: RegExp;
+        namespace?: string;
+    }, callback: (args: EsbuildResolveArgs) => EsbuildResolveResult | null | undefined | Promise<EsbuildResolveResult | null | undefined>) => void;
+    onLoad: (options: {
+        filter: RegExp;
+        namespace?: string;
+    }, callback: (args: EsbuildLoadArgs) => EsbuildLoadResult | null | undefined | Promise<EsbuildLoadResult | null | undefined>) => void;
+}
+interface EsbuildBuildOptions {
+    outdir?: string;
+    write?: boolean;
+    metafile?: boolean;
+}
+interface EsbuildResult {
+    errors: unknown[];
+    warnings: unknown[];
+    metafile?: unknown;
+}
+interface EsbuildResolveArgs {
+    path: string;
+    importer: string;
+    namespace: string;
+    resolveDir: string;
+    kind: string;
+}
+interface EsbuildResolveResult {
+    path?: string;
+    external?: boolean;
+    namespace?: string;
+    suffix?: string;
+    pluginData?: unknown;
+    errors?: unknown[];
+    warnings?: unknown[];
+    watchFiles?: string[];
+    watchDirs?: string[];
+}
+interface EsbuildLoadArgs {
+    path: string;
+    namespace: string;
+    suffix: string;
+    pluginData: unknown;
+}
+interface EsbuildLoadResult {
+    contents?: string;
+    loader?: 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'css';
+    resolveDir?: string;
+    errors?: unknown[];
+    warnings?: unknown[];
+    watchFiles?: string[];
+    watchDirs?: string[];
+}
+/**
+ * Plugin configuration
+ */
+interface FlightEsbuildPluginOptions {
+    /** Include patterns (regex) */
+    include?: RegExp;
+    /** Exclude patterns (regex) */
+    exclude?: RegExp;
+    /** Server actions endpoint */
+    actionsEndpoint?: string;
+    /** Output directory for manifests */
+    manifestDir?: string;
+    /** Is this for SSR build? */
+    ssr?: boolean;
+    /** Dev mode (include extra debug info) */
+    dev?: boolean;
+}
+/**
+ * Manifest entry
+ */
+interface ManifestEntry {
+    id: string;
+    file: string;
+    exports: string[];
+}
+/**
+ * Flight RSC esbuild Plugin
+ *
+ * @example
+ * ```typescript
+ * // build.js
+ * import * as esbuild from 'esbuild';
+ * import { flightRSCEsbuild } from '@flight-framework/core/rsc/plugins/esbuild';
+ *
+ * await esbuild.build({
+ *   entryPoints: ['src/index.tsx'],
+ *   bundle: true,
+ *   outdir: 'dist',
+ *   plugins: [
+ *     flightRSCEsbuild({
+ *       actionsEndpoint: '/_flight/action',
+ *       ssr: true,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function flightRSCEsbuild(options?: FlightEsbuildPluginOptions): EsbuildPlugin;
+
+export { type EsbuildBuild, type EsbuildBuildOptions, type EsbuildLoadArgs, type EsbuildLoadResult, type EsbuildPlugin, type EsbuildResolveArgs, type EsbuildResolveResult, type EsbuildResult, type FlightEsbuildPluginOptions, type ManifestEntry, flightRSCEsbuild as default, flightRSCEsbuild };

package/dist/rsc/plugins/esbuild.js

@@ -0,0 +1,4 @@
+export { esbuild_default as default, flightRSCEsbuild } from '../../chunk-T4Z4HM4W.js';
+import '../../chunk-PDW5WCMW.js';
+//# sourceMappingURL=esbuild.js.map
+//# sourceMappingURL=esbuild.js.map

package/dist/rsc/plugins/esbuild.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"esbuild.js"}

package/dist/rsc/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export { ClientManifestEntry, FlightRSCPluginOptions as FlightVitePluginOptions, ServerManifestEntry, default as flightRSCVite } from '../vite-plugin.js';
+export { EsbuildBuild, EsbuildLoadArgs, EsbuildLoadResult, EsbuildPlugin, EsbuildResolveArgs, EsbuildResolveResult, FlightEsbuildPluginOptions, ManifestEntry, default as flightRSCEsbuild } from './esbuild.js';
+export { FlightRollupPluginOptions, RollupPlugin, RollupPluginContext, default as flightRSCRollup } from './rollup.js';
+import 'vite';

package/dist/rsc/plugins/index.js

@@ -0,0 +1,6 @@
+export { flightRSCEsbuild } from '../../chunk-T4Z4HM4W.js';
+export { flightRSCRollup } from '../../chunk-NWMJYTMB.js';
+export { flightRSC as flightRSCVite } from '../../chunk-ZIE56LCA.js';
+import '../../chunk-PDW5WCMW.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/rsc/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/rsc/plugins/rollup.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @flight-framework/core - Rollup Plugin for RSC
+ *
+ * Rollup plugin for Flight Server Components.
+ * Transforms 'use client' and 'use server' directives at build time.
+ *
+ * Philosophy: Zero lock-in - Rollup is optional, user decides bundler.
+ *
+ * @module @flight-framework/core/rsc/plugins/rollup
+ */
+/**
+ * Rollup Plugin interface (minimal)
+ * We define our own to avoid requiring rollup as dependency
+ */
+interface RollupPlugin {
+    name: string;
+    buildStart?: (options: unknown) => void | Promise<void>;
+    resolveId?: (source: string, importer: string | undefined, options: {
+        isEntry: boolean;
+    }) => string | null | undefined | {
+        id: string;
+        external?: boolean;
+    } | Promise<string | null | undefined | {
+        id: string;
+        external?: boolean;
+    }>;
+    load?: (id: string) => string | null | undefined | {
+        code: string;
+        map?: unknown;
+    } | Promise<string | null | undefined | {
+        code: string;
+        map?: unknown;
+    }>;
+    transform?: (code: string, id: string) => string | null | undefined | {
+        code: string;
+        map?: unknown;
+    } | Promise<string | null | undefined | {
+        code: string;
+        map?: unknown;
+    }>;
+    generateBundle?: (options: unknown, bundle: Record<string, unknown>) => void | Promise<void>;
+    buildEnd?: (error?: Error) => void | Promise<void>;
+}
+interface RollupPluginContext {
+    emitFile: (file: {
+        type: 'asset' | 'chunk';
+        fileName?: string;
+        source?: string;
+        id?: string;
+    }) => string;
+    warn: (message: string) => void;
+    error: (message: string) => never;
+}
+/**
+ * Plugin configuration
+ */
+interface FlightRollupPluginOptions {
+    /** Include patterns (regex or function) */
+    include?: RegExp | ((id: string) => boolean);
+    /** Exclude patterns (regex or function) */
+    exclude?: RegExp | ((id: string) => boolean);
+    /** Server actions endpoint */
+    actionsEndpoint?: string;
+    /** Client manifest filename */
+    clientManifest?: string;
+    /** Server manifest filename */
+    serverManifest?: string;
+    /** Is this for SSR build? */
+    ssr?: boolean;
+    /** Dev mode */
+    dev?: boolean;
+}
+/**
+ * Manifest entry
+ */
+interface ManifestEntry {
+    id: string;
+    file: string;
+    exports: string[];
+}
+/**
+ * Flight RSC Rollup Plugin
+ *
+ * @example
+ * ```typescript
+ * // rollup.config.js
+ * import { flightRSCRollup } from '@flight-framework/core/rsc/plugins/rollup';
+ *
+ * export default {
+ *   input: 'src/index.tsx',
+ *   output: { dir: 'dist', format: 'esm' },
+ *   plugins: [
+ *     flightRSCRollup({
+ *       ssr: true,
+ *       actionsEndpoint: '/_flight/action',
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+declare function flightRSCRollup(options?: FlightRollupPluginOptions): RollupPlugin;
+
+export { type FlightRollupPluginOptions, type ManifestEntry, type RollupPlugin, type RollupPluginContext, flightRSCRollup as default, flightRSCRollup };

package/dist/rsc/plugins/rollup.js

@@ -0,0 +1,4 @@
+export { rollup_default as default, flightRSCRollup } from '../../chunk-NWMJYTMB.js';
+import '../../chunk-PDW5WCMW.js';
+//# sourceMappingURL=rollup.js.map
+//# sourceMappingURL=rollup.js.map

package/dist/rsc/plugins/rollup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"rollup.js"}

package/dist/rsc/renderer.d.ts

@@ -0,0 +1,160 @@
+import { FlightChunk, ServerComponentChunk, ClientReferenceChunk } from './payload.js';
+import { ServerContext } from './context.js';
+
+/**
+ * @flight-framework/core - Server Component Renderer
+ *
+ * Renders Server Components to FlightChunks.
+ * Framework-agnostic rendering engine that works with adapters.
+ *
+ * @module @flight-framework/core/rsc/renderer
+ */
+
+/**
+ * UI Framework adapter for rendering
+ */
+interface UIAdapter {
+    /** Adapter name */
+    name: string;
+    /** Check if value is a framework element */
+    isElement(value: unknown): boolean;
+    /** Get element type info */
+    getElementType(element: unknown): ElementTypeInfo;
+    /** Get element props */
+    getProps(element: unknown): Record<string, unknown>;
+    /** Get element children */
+    getChildren(element: unknown): unknown[];
+    /** Get element key */
+    getKey(element: unknown): string | number | undefined;
+    /** Check if component is a client boundary */
+    isClientBoundary(component: unknown): boolean;
+    /** Render element to HTML string (for SSR fallback) */
+    renderToString?(element: unknown): Promise<string>;
+}
+type ElementTypeInfo = {
+    kind: 'host';
+    tag: string;
+} | {
+    kind: 'component';
+    fn: ComponentFn;
+    name: string;
+} | {
+    kind: 'fragment';
+} | {
+    kind: 'suspense';
+    fallback?: unknown;
+} | {
+    kind: 'provider';
+    value?: unknown;
+} | {
+    kind: 'context';
+} | {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'null';
+};
+/**
+ * Component function type
+ */
+type ComponentFn = (props: Record<string, unknown>, ctx?: ServerContext) => unknown | Promise<unknown>;
+/**
+ * Render options
+ */
+interface RenderOptions {
+    /** Include SSR fallbacks for client components */
+    includeSSRFallbacks?: boolean;
+    /** Error handler */
+    onError?: (error: Error, componentName?: string) => void;
+    /** Dev mode (include extra debug info) */
+    dev?: boolean;
+    /** Max render depth to prevent infinite loops */
+    maxDepth?: number;
+}
+/**
+ * Render result with metadata
+ */
+interface RenderResult {
+    /** All chunks generated */
+    chunks: FlightChunk[];
+    /** Root chunk */
+    root: ServerComponentChunk;
+    /** Client references found */
+    clientRefs: ClientReferenceChunk[];
+    /** Timing info */
+    timing: {
+        startTime: number;
+        endTime: number;
+        duration: number;
+    };
+}
+/**
+ * Flight Server Component Renderer
+ */
+declare class FlightRenderer {
+    private adapter;
+    private options;
+    private chunks;
+    private clientRefs;
+    private pendingPromises;
+    private depth;
+    constructor(adapter: UIAdapter, options?: RenderOptions);
+    /**
+     * Render a component tree to Flight chunks
+     */
+    render(element: unknown, ctx: ServerContext): Promise<RenderResult>;
+    /**
+     * Render as async generator (for streaming)
+     */
+    renderStreaming(element: unknown, ctx: ServerContext): AsyncGenerator<FlightChunk>;
+    /**
+     * Render an element to FlightElement
+     */
+    private renderElement;
+    /**
+     * Render a framework-specific element
+     */
+    private renderFrameworkElement;
+    /**
+     * Render a host element (div, span, etc.)
+     */
+    private renderHostElement;
+    /**
+     * Render a component (server or client)
+     */
+    private renderComponent;
+    /**
+     * Render a client boundary
+     */
+    private renderClientBoundary;
+    /**
+     * Render a Suspense boundary
+     */
+    private renderSuspense;
+    /**
+     * Render an async boundary (promise thrown from component)
+     */
+    private renderAsyncBoundary;
+    /**
+     * Render a Client Reference directly
+     */
+    private renderClientReference;
+    /**
+     * Resolve all pending async chunks
+     */
+    private resolvePendingChunks;
+}
+/**
+ * Create a renderer with adapter
+ */
+declare function createRenderer(adapter: UIAdapter, options?: RenderOptions): FlightRenderer;
+/**
+ * Render a server component tree
+ */
+declare function renderServerComponent<P>(component: ComponentFn, props: P, ctx: ServerContext, adapter: UIAdapter, options?: RenderOptions): Promise<RenderResult>;
+/**
+ * Render server component as streaming chunks
+ */
+declare function renderServerComponentStreaming<P>(component: ComponentFn, props: P, ctx: ServerContext, adapter: UIAdapter, options?: RenderOptions): AsyncGenerator<FlightChunk>;
+
+export { type ComponentFn, type ElementTypeInfo, FlightRenderer, type RenderOptions, type RenderResult, type UIAdapter, createRenderer, renderServerComponent, renderServerComponentStreaming };

package/dist/rsc/renderer.js

@@ -0,0 +1,5 @@
+export { FlightRenderer, createRenderer, renderServerComponent, renderServerComponentStreaming } from '../chunk-HAX5OAB6.js';
+import '../chunk-K2CQZPCG.js';
+import '../chunk-PDW5WCMW.js';
+//# sourceMappingURL=renderer.js.map
+//# sourceMappingURL=renderer.js.map

package/dist/rsc/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"renderer.js"}

package/dist/rsc/stream.d.ts

@@ -0,0 +1,129 @@
+import { FlightChunk, ServerComponentChunk, ErrorBoundaryChunk } from './payload.js';
+
+/**
+ * @flight-framework/core - Flight Stream
+ *
+ * Protocolo de streaming para Server Components.
+ * Usa NDJSON (Newline Delimited JSON) para máxima debuggabilidad.
+ *
+ * Filosofía Flight:
+ * - Formato abierto y documentado
+ * - Works con cualquier runtime (Node, Deno, Bun, Edge)
+ * - Fácil de debuggear (text-based)
+ * - Sin dependencias
+ *
+ * @module @flight-framework/core/rsc/stream
+ */
+
+/**
+ * Opciones para crear un FlightStream
+ */
+interface FlightStreamOptions {
+    /** Incluir timestamps en chunks */
+    timestamps?: boolean;
+    /** Prefix para IDs generados */
+    idPrefix?: string;
+    /** Callback cuando un chunk es enviado */
+    onChunk?: (chunk: FlightChunk) => void;
+    /** Callback cuando el stream termina */
+    onComplete?: () => void;
+    /** Callback en caso de error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Resultado del parsing de un FlightStream
+ */
+interface FlightStreamResult {
+    /** Chunks recibidos */
+    chunks: FlightChunk[];
+    /** Componente raíz */
+    root?: ServerComponentChunk;
+    /** Errores encontrados */
+    errors: ErrorBoundaryChunk[];
+    /** Tiempo total de streaming en ms */
+    duration: number;
+}
+/**
+ * Crea un ReadableStream desde un AsyncIterable de chunks
+ *
+ * @example
+ * ```typescript
+ * async function* renderApp() {
+ *   yield createServerChunk('root', tree);
+ *   yield createClientChunk('counter', './Counter', 'default', { initial: 0 });
+ * }
+ *
+ * const stream = createFlightStream(renderApp());
+ * return new Response(stream, { headers: { 'Content-Type': 'text/x-flight' } });
+ * ```
+ */
+declare function createFlightStream(chunks: AsyncIterable<FlightChunk>, options?: FlightStreamOptions): ReadableStream<Uint8Array>;
+/**
+ * Crea un FlightStream desde un array de chunks
+ */
+declare function createFlightStreamFromArray(chunks: FlightChunk[], options?: FlightStreamOptions): ReadableStream<Uint8Array>;
+/**
+ * Parsea un FlightStream a chunks individuales
+ *
+ * @example
+ * ```typescript
+ * // En el cliente
+ * const response = await fetch('/page');
+ * const chunks = parseFlightStream(response.body!);
+ *
+ * for await (const chunk of chunks) {
+ *   handleChunk(chunk);
+ * }
+ * ```
+ */
+declare function parseFlightStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<FlightChunk>;
+/**
+ * Parsea un string completo de FlightStream
+ */
+declare function parseFlightStreamSync(data: string): FlightChunk[];
+/**
+ * Consume un FlightStream y retorna todos los chunks
+ */
+declare function consumeFlightStream(stream: ReadableStream<Uint8Array>): Promise<FlightStreamResult>;
+/**
+ * Crea una Response con Flight payload
+ */
+declare function createFlightResponse(chunks: AsyncIterable<FlightChunk>, options?: FlightResponseOptions): Response;
+interface FlightResponseOptions {
+    status?: number;
+    headers?: Record<string, string>;
+}
+/**
+ * Crea una Response HTML con streaming SSR + Flight payload embebido
+ */
+declare function createHybridResponse(htmlStream: ReadableStream<Uint8Array>, flightChunks: FlightChunk[], options?: FlightResponseOptions): Response;
+/**
+ * Crea un stream controller para enviar chunks progresivamente
+ */
+declare function createStreamController(): {
+    stream: ReadableStream<Uint8Array>;
+    enqueue: (chunk: FlightChunk) => void;
+    error: (error: Error) => void;
+    close: () => void;
+};
+/**
+ * Merge múltiples streams en uno solo (para rendering paralelo)
+ */
+declare function mergeFlightStreams(...streams: ReadableStream<Uint8Array>[]): ReadableStream<Uint8Array>;
+/**
+ * Pipe a flight stream through a transform
+ */
+declare function transformFlightStream(stream: ReadableStream<Uint8Array>, transform: (chunk: FlightChunk) => FlightChunk | null | Promise<FlightChunk | null>): ReadableStream<Uint8Array>;
+/**
+ * Pretty print Flight chunks para debugging
+ */
+declare function prettyPrintChunks(chunks: FlightChunk[]): string;
+/**
+ * Error durante parsing de FlightStream
+ */
+declare class FlightStreamError extends Error {
+    readonly rawData?: string | undefined;
+    constructor(message: string, rawData?: string | undefined);
+}
+
+export { type FlightResponseOptions, FlightStreamError, type FlightStreamOptions, type FlightStreamResult, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream };

package/dist/rsc/stream.js

@@ -0,0 +1,3 @@
+export { FlightStreamError, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream } from '../chunk-PVUMB632.js';
+//# sourceMappingURL=stream.js.map
+//# sourceMappingURL=stream.js.map

package/dist/rsc/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"stream.js"}

package/dist/rsc/vite-plugin.d.ts

@@ -0,0 +1,78 @@
+import { Plugin } from 'vite';
+
+/**
+ * @flight-framework/vite-plugin-rsc
+ *
+ * Vite plugin for Flight Server Components.
+ * Transforms 'use client' and 'use server' directives at build time.
+ *
+ * Philosophy:
+ * - Zero config for common cases
+ * - Full control when needed
+ * - Works with any Vite project
+ * - No Next.js dependencies
+ *
+ * @module @flight-framework/vite-plugin-rsc
+ */
+
+/**
+ * Plugin configuration
+ */
+interface FlightRSCPluginOptions {
+    /** Include patterns (glob) */
+    include?: string[];
+    /** Exclude patterns (glob) */
+    exclude?: string[];
+    /** Server actions endpoint */
+    actionsEndpoint?: string;
+    /** Client manifest output path */
+    clientManifest?: string;
+    /** Server manifest output path */
+    serverManifest?: string;
+    /** Enable dev mode features */
+    dev?: boolean;
+    /** Custom transforms */
+    transforms?: {
+        /** Transform client components */
+        client?: (code: string, id: string) => string | null;
+        /** Transform server actions */
+        server?: (code: string, id: string) => string | null;
+    };
+}
+/**
+ * Client manifest entry
+ */
+interface ClientManifestEntry {
+    id: string;
+    file: string;
+    exports: string[];
+    chunks?: string[];
+}
+/**
+ * Server manifest entry
+ */
+interface ServerManifestEntry {
+    id: string;
+    file: string;
+    actions: string[];
+}
+/**
+ * Flight RSC Vite Plugin
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { flightRSC } from '@flight-framework/core/rsc/vite-plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     flightRSC({
+ *       actionsEndpoint: '/_flight/action',
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function flightRSC(options?: FlightRSCPluginOptions): Plugin[];
+
+export { type ClientManifestEntry, type FlightRSCPluginOptions, type ServerManifestEntry, flightRSC as default, flightRSC };

package/dist/rsc/vite-plugin.js

@@ -0,0 +1,4 @@
+export { vite_plugin_default as default, flightRSC } from '../chunk-ZIE56LCA.js';
+import '../chunk-PDW5WCMW.js';
+//# sourceMappingURL=vite-plugin.js.map
+//# sourceMappingURL=vite-plugin.js.map

package/dist/rsc/vite-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"vite-plugin.js"}

package/dist/streaming/index.js

@@ -1,3 +1,3 @@
-export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from '../chunk-6WSPUG5L.js';
+export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from '../chunk-RSVA2EYO.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/streaming/observability.js

@@ -1,4 +1,4 @@
-export { MetricsAggregator, createHttpObserver, createInstrumentedStream, createLoggerObserver } from '../chunk-YIOQC3DC.js';
-import '../chunk-6WSPUG5L.js';
+export { MetricsAggregator, createHttpObserver, createInstrumentedStream, createLoggerObserver } from '../chunk-6BDCTUQY.js';
+import '../chunk-RSVA2EYO.js';
 //# sourceMappingURL=observability.js.map
 //# sourceMappingURL=observability.js.map

package/dist/streaming/priority.js

@@ -1,3 +1,3 @@
-export { streamWithPriority, validateDependencies } from '../chunk-OBNYNJB5.js';
+export { streamWithPriority, validateDependencies } from '../chunk-WOEIJWGJ.js';
 //# sourceMappingURL=priority.js.map
 //# sourceMappingURL=priority.js.map