@flight-framework/core 0.0.3 → 0.2.0

package/dist/rsc/legacy.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @flight-framework/core - Legacy RSC Support
+ *
+ * Backward compatibility module for the original RSC implementation.
+ * Use the new API from './index.js' for new features.
+ *
+ * @deprecated Use the new RSC API instead
+ * @module @flight-framework/core/rsc/legacy
+ */
+/**
+ * Component rendering context
+ * @deprecated Use ServerContext from './context.js' instead
+ */
+interface RenderContext {
+    /** Current request */
+    request: Request;
+    /** Route params */
+    params: Record<string, string>;
+    /** Search params */
+    searchParams: URLSearchParams;
+    /** Request headers */
+    headers: Headers;
+    /** Cookies */
+    cookies: Map<string, string>;
+}
+/**
+ * Server component definition
+ * @deprecated Use ServerComponentFn from './index.js' instead
+ */
+interface ServerComponent<P = unknown> {
+    (props: P, context: RenderContext): Promise<string> | string;
+    /** Mark as server component */
+    __flight_server?: true;
+    /** Dependencies for hydration */
+    __flight_deps?: string[];
+}
+/**
+ * Client component definition
+ * @deprecated Use ClientReference from './boundaries.js' instead
+ */
+interface ClientComponent<P = unknown> {
+    (props: P): unknown;
+    /** Mark as client component */
+    __flight_client?: true;
+    /** Client bundle path */
+    __flight_bundle?: string;
+}
+/**
+ * Component type detection
+ */
+type ComponentType = 'server' | 'client' | 'hybrid';
+/**
+ * Execute an async server component
+ * @deprecated Use the new rendering pipeline instead
+ */
+declare function executeServerComponent<P>(component: ServerComponent<P>, props: P, context: RenderContext): Promise<string>;
+/**
+ * Create a render context from a Request
+ * @deprecated Use createServerContext from './context.js' instead
+ */
+declare function createRenderContext(request: Request, params?: Record<string, string>): RenderContext;
+/**
+ * Server-side fetch with automatic caching
+ */
+declare function serverFetch<T>(url: string, options?: RequestInit & {
+    revalidate?: number | false;
+    tags?: string[];
+}): Promise<T>;
+/**
+ * Invalidate cache by tag
+ */
+declare function revalidateTag(tag: string): void;
+/**
+ * Invalidate cache by path
+ */
+declare function revalidatePath(path: string): void;
+/**
+ * Serialize props for transmission to client
+ * @deprecated Use serialize from './payload.js' instead
+ */
+declare function serializeProps(props: unknown): string;
+/**
+ * Deserialize props on client
+ * @deprecated Use deserialize from './payload.js' instead
+ */
+declare function deserializeProps<T>(serialized: string): T;
+/**
+ * Create a client boundary placeholder
+ * @deprecated Use clientRef from './payload.js' instead
+ */
+declare function createClientBoundary(componentId: string, props: unknown, fallback?: string): string;
+/**
+ * Helper to create an async server component
+ * @deprecated Use async Server Components directly
+ */
+declare function createAsyncComponent<P, T>(fetcher: (props: P, context: RenderContext) => Promise<T>, renderer: (data: T, props: P) => string): ServerComponent<P>;
+/**
+ * Compose multiple server components
+ * @deprecated Use Promise.all with async components
+ */
+declare function composeComponents(...components: Array<() => Promise<string> | string>): () => Promise<string>;
+/**
+ * Wrap a server component with error handling
+ * @deprecated Use try/catch in async components
+ */
+declare function withErrorBoundary<P>(component: ServerComponent<P>, errorFallback: (error: Error) => string): ServerComponent<P>;
+/**
+ * Throw a not found error
+ * @deprecated Use notFound from './context.js' instead
+ */
+declare function notFound(): never;
+/**
+ * Check if error is not found
+ * @deprecated Use isNotFoundError from './context.js' instead
+ */
+declare function isNotFoundError(error: unknown): boolean;
+/**
+ * Server-side redirect
+ * @deprecated Use redirect from './context.js' instead
+ */
+declare function redirect(url: string, type?: 'replace' | 'push'): never;
+/**
+ * Check if error is redirect
+ * @deprecated Use isRedirectError from './context.js' instead
+ */
+declare function isRedirectError(error: unknown): {
+    url: string;
+    type: string;
+} | null;
+
+export { type ClientComponent, type ComponentType, type RenderContext, type ServerComponent, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary };

package/dist/rsc/legacy.js

@@ -0,0 +1,3 @@
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary } from '../chunk-3AY23FZP.js';
+//# sourceMappingURL=legacy.js.map
+//# sourceMappingURL=legacy.js.map

package/dist/rsc/legacy.js.map

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

package/dist/rsc/payload.d.ts

@@ -0,0 +1,262 @@
+/**
+ * @flight-framework/core - Flight Payload System
+ *
+ * Formato de serialización agnóstico para Server Components.
+ * Diseñado para máxima debuggabilidad y compatibilidad multi-framework.
+ *
+ * Filosofía Flight:
+ * - Formato documentado y abierto (NDJSON)
+ * - No depende de internals de React
+ * - Extensible para cualquier UI framework
+ * - Zero vendor lock-in
+ *
+ * @module @flight-framework/core/rsc/payload
+ */
+/**
+ * Union type de todos los chunks que pueden enviarse en un FlightStream
+ */
+type FlightChunk = ServerComponentChunk | ClientReferenceChunk | ServerReferenceChunk | ErrorBoundaryChunk | HintChunk | MetaChunk;
+/**
+ * Chunk de Server Component renderizado
+ * Contiene el árbol virtual de elementos
+ */
+interface ServerComponentChunk {
+    /** Discriminator */
+    readonly type: 'S';
+    /** Unique chunk ID */
+    readonly id: string;
+    /** Virtual element tree */
+    readonly tree: FlightElement;
+    /** IDs de chunks que este depende (para streaming ordenado) */
+    readonly awaiting?: readonly string[];
+    /** Timestamp para debugging/observability */
+    readonly ts?: number;
+}
+/**
+ * Referencia a un Client Component
+ * El cliente cargará el módulo y lo hidratará
+ */
+interface ClientReferenceChunk {
+    /** Discriminator */
+    readonly type: 'C';
+    /** Reference ID */
+    readonly id: string;
+    /** Module specifier (relativo al manifest) */
+    readonly module: string;
+    /** Export name */
+    readonly export: string;
+    /** Serialized props */
+    readonly props: SerializedValue;
+    /** Fallback HTML para SSR (opcional) */
+    readonly fallback?: string;
+}
+/**
+ * Referencia a una Server Function (Action)
+ * El cliente la invocará via RPC
+ */
+interface ServerReferenceChunk {
+    /** Discriminator */
+    readonly type: 'A';
+    /** Action ID */
+    readonly id: string;
+    /** Bound arguments (pre-bound via .bind()) */
+    readonly bound?: readonly SerializedValue[];
+}
+/**
+ * Error en un boundary específico
+ */
+interface ErrorBoundaryChunk {
+    /** Discriminator */
+    readonly type: 'E';
+    /** Boundary ID where error occurred */
+    readonly boundary: string;
+    /** Safe error message for client */
+    readonly message: string;
+    /** Error digest for server-side correlation */
+    readonly digest: string;
+    /** Component stack for development */
+    readonly stack?: string;
+}
+/**
+ * Hints para el cliente (preload, prefetch, etc.)
+ */
+interface HintChunk {
+    /** Discriminator */
+    readonly type: 'H';
+    /** Hint type */
+    readonly hint: 'preload' | 'prefetch' | 'dns-prefetch' | 'preconnect' | 'modulepreload';
+    /** Resource URL */
+    readonly href: string;
+    /** Resource type (for preload) */
+    readonly as?: 'script' | 'style' | 'image' | 'font' | 'fetch';
+    /** Crossorigin attribute */
+    readonly crossorigin?: 'anonymous' | 'use-credentials';
+}
+/**
+ * Metadata chunk (para SSR head injection)
+ */
+interface MetaChunk {
+    /** Discriminator */
+    readonly type: 'M';
+    /** Meta type */
+    readonly meta: 'title' | 'description' | 'og' | 'twitter' | 'link' | 'script';
+    /** Content */
+    readonly content: string | Record<string, string>;
+}
+/**
+ * Virtual element que puede representar cualquier UI framework
+ */
+type FlightElement = FlightHostElement | FlightTextElement | FlightFragmentElement | FlightSuspenseElement | FlightClientElement | FlightLazyElement | FlightNullElement;
+/**
+ * Host element (div, span, etc.)
+ */
+interface FlightHostElement {
+    readonly $$type: 'host';
+    readonly tag: string;
+    readonly key?: string | number;
+    readonly props: Readonly<Record<string, SerializedValue>>;
+    readonly children: readonly FlightElement[];
+}
+/**
+ * Text node
+ */
+interface FlightTextElement {
+    readonly $$type: 'text';
+    readonly value: string;
+}
+/**
+ * Fragment (multiple children, no wrapper)
+ */
+interface FlightFragmentElement {
+    readonly $$type: 'fragment';
+    readonly children: readonly FlightElement[];
+}
+/**
+ * Suspense boundary
+ */
+interface FlightSuspenseElement {
+    readonly $$type: 'suspense';
+    readonly id: string;
+    readonly fallback: FlightElement;
+    readonly children: readonly FlightElement[];
+}
+/**
+ * Client component reference
+ */
+interface FlightClientElement {
+    readonly $$type: 'client';
+    /** Reference to ClientReferenceChunk ID */
+    readonly ref: string;
+    /** Pre-rendered fallback HTML */
+    readonly ssr?: string;
+}
+/**
+ * Lazy/async element (pending resolution)
+ */
+interface FlightLazyElement {
+    readonly $$type: 'lazy';
+    readonly id: string;
+    readonly fallback?: FlightElement;
+}
+/**
+ * Null/empty element
+ */
+interface FlightNullElement {
+    readonly $$type: 'null';
+}
+/**
+ * Valores que pueden cruzar el boundary server/client
+ */
+type SerializedValue = string | number | boolean | null | undefined | readonly SerializedValue[] | {
+    readonly [key: string]: SerializedValue;
+} | SerializedSpecialValue;
+/**
+ * Tipos especiales que requieren serialización custom
+ */
+interface SerializedSpecialValue {
+    readonly $$flight: SpecialValueType;
+    readonly value: string | readonly unknown[];
+}
+type SpecialValueType = 'date' | 'bigint' | 'map' | 'set' | 'undefined' | 'symbol' | 'regexp' | 'url' | 'error' | 'formdata' | 'blob' | 'arraybuffer';
+/**
+ * Serializa un valor para transmisión a través de FlightStream
+ */
+declare function serialize(value: unknown): SerializedValue;
+/**
+ * Deserializa un valor recibido de FlightStream
+ */
+declare function deserialize<T = unknown>(value: SerializedValue): T;
+/**
+ * Create a host element
+ */
+declare function h(tag: string, props: Record<string, unknown> | null, ...children: unknown[]): FlightHostElement;
+/**
+ * Create a text element
+ */
+declare function text(value: string): FlightTextElement;
+/**
+ * Create a fragment
+ */
+declare function fragment(...children: unknown[]): FlightFragmentElement;
+/**
+ * Create a suspense boundary
+ */
+declare function suspense(id: string, fallback: FlightElement, children: FlightElement[]): FlightSuspenseElement;
+/**
+ * Create a client component reference
+ */
+declare function clientRef(refId: string, ssrHtml?: string): FlightClientElement;
+/**
+ * Convert any value to a FlightElement
+ */
+declare function toFlightElement(value: unknown): FlightElement;
+/**
+ * Type guard for FlightElement
+ */
+declare function isFlightElement(value: unknown): value is FlightElement;
+/**
+ * Generate unique chunk ID
+ */
+declare function generateChunkId(prefix?: string): string;
+/**
+ * Reset chunk ID counter (for testing)
+ */
+declare function resetChunkIdCounter(): void;
+/**
+ * Create a server component chunk
+ */
+declare function createServerChunk(id: string, tree: FlightElement, awaiting?: string[]): ServerComponentChunk;
+/**
+ * Create a client reference chunk
+ */
+declare function createClientChunk(id: string, module: string, exportName: string, props: unknown, fallback?: string): ClientReferenceChunk;
+/**
+ * Create a server reference (action) chunk
+ */
+declare function createActionChunk(id: string, boundArgs?: unknown[]): ServerReferenceChunk;
+/**
+ * Create an error chunk
+ */
+declare function createErrorChunk(boundary: string, error: Error, includeStack?: boolean): ErrorBoundaryChunk;
+/**
+ * Create a hint chunk
+ */
+declare function createHintChunk(hint: HintChunk['hint'], href: string, options?: {
+    as?: HintChunk['as'];
+    crossorigin?: HintChunk['crossorigin'];
+}): HintChunk;
+/**
+ * Error thrown during serialization
+ */
+declare class FlightSerializationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown during payload processing
+ */
+declare class FlightPayloadError extends Error {
+    readonly chunk?: FlightChunk | undefined;
+    constructor(message: string, chunk?: FlightChunk | undefined);
+}
+
+export { type ClientReferenceChunk, type ErrorBoundaryChunk, type FlightChunk, type FlightClientElement, type FlightElement, type FlightFragmentElement, type FlightHostElement, type FlightLazyElement, type FlightNullElement, FlightPayloadError, FlightSerializationError, type FlightSuspenseElement, type FlightTextElement, type HintChunk, type MetaChunk, type SerializedSpecialValue, type SerializedValue, type ServerComponentChunk, type ServerReferenceChunk, type SpecialValueType, clientRef, createActionChunk, createClientChunk, createErrorChunk, createHintChunk, createServerChunk, deserialize, fragment, generateChunkId, h, isFlightElement, resetChunkIdCounter, serialize, suspense, text, toFlightElement };

package/dist/rsc/payload.js

@@ -0,0 +1,3 @@
+export { FlightPayloadError, FlightSerializationError, clientRef, createActionChunk, createClientChunk, createErrorChunk, createHintChunk, createServerChunk, deserialize, fragment, generateChunkId, h, isFlightElement, resetChunkIdCounter, serialize, suspense, text, toFlightElement } from '../chunk-K2CQZPCG.js';
+//# sourceMappingURL=payload.js.map
+//# sourceMappingURL=payload.js.map

package/dist/rsc/payload.js.map

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

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-6XZQPPYC.js';
+import '../../chunk-CLZSB5QD.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-6XZQPPYC.js';
+export { flightRSCRollup } from '../../chunk-5GUCB2CG.js';
+export { flightRSC as flightRSCVite } from '../../chunk-MRLCNFSD.js';
+import '../../chunk-CLZSB5QD.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-5GUCB2CG.js';
+import '../../chunk-CLZSB5QD.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"}