@spring-systems/core 0.8.0

package/dist/instance/index.d.ts

@@ -0,0 +1,112 @@
+import { F as FrameworkConfigOverrides } from '../framework-config-types-DeUbx4bu.js';
+import { d as SpringInstance } from '../spring-instance-EbUh4mQb.js';
+export { H as HandlerEntry, I as InstanceContentAdapter, e as InstanceLifecycleState, c as InstanceLogAdapter, b as InstanceNotificationAdapter, L as LogoutHandler, a as LogoutReason, R as RequestHook, f as ResponseHook, S as SecurityEventType, g as SpringApiState, h as SpringCoreState, i as SpringUIState } from '../spring-instance-EbUh4mQb.js';
+import '../middleware-types-DVG9C1qJ.js';
+import '../form-types-D3MdGpjA.js';
+import '../security-sanitize-Bb0PExM6.js';
+
+/**
+ * Factory for creating SpringInstance — a clean state container with all defaults.
+ *
+ * Lifecycle: `creating` → `ready` → `disposing` → `disposed`
+ *
+ * @module create-instance
+ */
+
+/**
+ * Create a fresh SpringInstance with clean state.
+ * Each instance gets its own event listeners, middleware registry, validators, etc.
+ *
+ * The instance starts in `creating` state. Call `markInstanceReady()` after
+ * applying plugins and fallbacks to transition to `ready`.
+ *
+ * @param overrides - Partial config overrides merged with DEFAULT_FRAMEWORK_CONFIG (deep-merged per section)
+ * @returns A new SpringInstance in `creating` lifecycle state with a unique ID.
+ */
+declare function createSpringInstance(overrides?: FrameworkConfigOverrides): SpringInstance;
+/**
+ * Transition an instance to `ready` state.
+ * Should be called after all initialization (plugins, fallbacks, adapters) is complete.
+ */
+declare function markInstanceReady(instance: SpringInstance): void;
+/**
+ * Run one-time activation work for an instance and transition it to `ready`.
+ *
+ * Safe under StrictMode and remounts:
+ * - render phase may create the instance, but activation happens later
+ * - repeated activation on the same ready instance is a no-op
+ * - bootstrap failures clear the current-instance bridge before rethrowing
+ */
+declare function bootstrapSpringInstance(instance: SpringInstance, activate: () => void): void;
+/**
+ * Check if an instance is in a usable state (creating or ready).
+ */
+declare function isInstanceActive(instance: SpringInstance): boolean;
+
+/**
+ * Current instance bridge — the one remaining singleton.
+ * Imperative code (API calls, middleware, etc.) reads from getSpringInstance().
+ * The SpringProvider in ui sets this via setSpringInstance().
+ *
+ * **SSR safety note:** This module uses a module-level variable, which means
+ * concurrent SSR requests in the same Node.js process will share the same
+ * instance. For multi-tenant SSR, use React Context instead of getSpringInstance().
+ *
+ * @module current-instance
+ */
+
+/**
+ * Set the current SpringInstance. Called once by SpringProvider on mount.
+ * Warns if replacing an active (non-disposed) instance — this indicates
+ * either multiple SpringProviders or missing cleanup.
+ */
+declare function setSpringInstance(instance: SpringInstance): void;
+/**
+ * Get the current SpringInstance. Throws if not set.
+ * Use this in imperative code that requires a live instance.
+ */
+declare function getSpringInstance(): SpringInstance;
+/**
+ * Get the current SpringInstance or null if not yet initialized.
+ * Use this in code that may run before SpringProvider mounts (e.g. config setup).
+ */
+declare function tryGetSpringInstance(): SpringInstance | null;
+/**
+ * Clear the current instance. For testing and cleanup only.
+ */
+declare function clearSpringInstance(): void;
+
+/**
+ * Centralized fallback bridge — migrates pre-mount state to a SpringInstance.
+ *
+ * Before SpringProvider mounts, various modules (config, adapters, event bus,
+ * middleware) store state in module-level fallback variables. When SpringProvider
+ * creates and sets the SpringInstance, this function migrates all fallback state
+ * to the instance in a single call.
+ *
+ * This replaces the previous pattern where each module independently checked
+ * tryGetSpringInstance() and maintained its own fallback state.
+ *
+ * @module fallback-bridge
+ */
+
+/**
+ * Migrate all pre-mount fallback state into the given SpringInstance.
+ * Called once by SpringProvider after instance creation.
+ *
+ * Modules register their fallback migration via registerFallbackMigration().
+ * This allows packages (ui, api) to register their own migrations
+ * without core needing to know about them.
+ */
+declare function applyAllFallbacks(instance: SpringInstance): void;
+type FallbackMigration = (instance: SpringInstance) => void;
+/**
+ * Register a fallback migration function.
+ * Called by modules that maintain pre-mount fallback state (adapters, event bus, etc.)
+ * to ensure their state is migrated when SpringProvider mounts.
+ */
+declare function registerFallbackMigration(migration: FallbackMigration, priority?: number): void;
+/** Clear all registered migrations. For testing only. */
+declare function clearFallbackMigrations(): void;
+
+export { SpringInstance, applyAllFallbacks, bootstrapSpringInstance, clearFallbackMigrations, clearSpringInstance, createSpringInstance, getSpringInstance, isInstanceActive, markInstanceReady, registerFallbackMigration, setSpringInstance, tryGetSpringInstance };

package/dist/instance/index.js

@@ -0,0 +1,37 @@
+import {
+  bootstrapSpringInstance,
+  createSpringInstance,
+  isInstanceActive,
+  markInstanceReady
+} from "../chunk-F2SIMWZ5.js";
+import "../chunk-GXU75LQX.js";
+import "../chunk-S7MKRNMI.js";
+import "../chunk-F7WUQJH7.js";
+import "../chunk-N2L4TUC4.js";
+import {
+  applyAllFallbacks,
+  clearFallbackMigrations,
+  registerFallbackMigration
+} from "../chunk-RUCXSQEY.js";
+import "../chunk-KX32MU3I.js";
+import {
+  clearSpringInstance,
+  getSpringInstance,
+  setSpringInstance,
+  tryGetSpringInstance
+} from "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+export {
+  applyAllFallbacks,
+  bootstrapSpringInstance,
+  clearFallbackMigrations,
+  clearSpringInstance,
+  createSpringInstance,
+  getSpringInstance,
+  isInstanceActive,
+  markInstanceReady,
+  registerFallbackMigration,
+  setSpringInstance,
+  tryGetSpringInstance
+};
+//# sourceMappingURL=index.js.map

package/dist/instance/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/logger/index.d.ts

@@ -0,0 +1,44 @@
+import { S as SecurityEventType } from '../spring-instance-EbUh4mQb.js';
+import { S as SecurityLogData } from '../security-sanitize-Bb0PExM6.js';
+import '../framework-config-types-DeUbx4bu.js';
+import '../middleware-types-DVG9C1qJ.js';
+import '../form-types-D3MdGpjA.js';
+
+/**
+ * Console wrapper with timestamp and configurable log levels.
+ * @module logger
+ */
+
+type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+type BivariantCallback<TArgs extends unknown[], TResult = void> = {
+    bivarianceHack: (...args: TArgs) => TResult;
+}["bivarianceHack"];
+interface LogAdapter {
+    onError?: (context: string, error?: unknown) => void;
+    onWarn?: (context: string, message?: string) => void;
+    onSecurityEvent?: BivariantCallback<[event: SecurityEventType, data?: SecurityLogData]>;
+}
+/**
+ * Set the minimum log level. Messages below this level are suppressed.
+ * Default is "info" in production, "debug" in development.
+ */
+declare function setLogLevel(level: LogLevel): void;
+/**
+ * Get the current log level.
+ */
+declare function getLogLevel(): LogLevel;
+declare function setLogAdapter(a: LogAdapter): void;
+/**
+ * Reset adapter callbacks to defaults (no-op adapter).
+ * For testing/integration teardown only.
+ */
+declare function clearLogAdapter(): void;
+/** Reset log level to runtime default (info in prod, debug otherwise). */
+declare function resetLogLevel(): void;
+declare function logDebug(context: string, data?: unknown): void;
+declare function logError(context: string, error?: unknown): void;
+declare function logWarn(context: string, message?: string): void;
+declare function logInfo(context: string, data?: unknown): void;
+declare function logSecurityEvent(event: SecurityEventType, data?: SecurityLogData): void;
+
+export { type LogAdapter, type LogLevel, clearLogAdapter, getLogLevel, logDebug, logError, logInfo, logSecurityEvent, logWarn, resetLogLevel, setLogAdapter, setLogLevel };

package/dist/logger/index.js

@@ -0,0 +1,27 @@
+import {
+  clearLogAdapter,
+  getLogLevel,
+  logDebug,
+  logError,
+  logInfo,
+  logSecurityEvent,
+  logWarn,
+  resetLogLevel,
+  setLogAdapter,
+  setLogLevel
+} from "../chunk-KX32MU3I.js";
+import "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+export {
+  clearLogAdapter,
+  getLogLevel,
+  logDebug,
+  logError,
+  logInfo,
+  logSecurityEvent,
+  logWarn,
+  resetLogLevel,
+  setLogAdapter,
+  setLogLevel
+};
+//# sourceMappingURL=index.js.map

package/dist/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/middleware/index.d.ts

@@ -0,0 +1,91 @@
+import { M as MiddlewareOptions } from '../middleware-registry-DT002qRd.js';
+export { c as clearAllMiddleware, g as getMiddlewareRunner, a as getRegisteredMiddlewareSlots, r as registerMiddleware } from '../middleware-registry-DT002qRd.js';
+import { a as MiddlewareFn } from '../middleware-types-DVG9C1qJ.js';
+export { A as ApiRequestContext, F as FormDeleteContext, c as FormLoadContext, d as FormSaveContext, L as ListLoadContext, b as MiddlewareEntry, M as MiddlewareSlot, e as MiddlewareSlotMap } from '../middleware-types-DVG9C1qJ.js';
+
+/**
+ * Audit middleware — standardized audit event creation for form mutations.
+ *
+ * Provides a typed `AuditEvent` and factory functions that hook into
+ * `form:afterSave` and `form:afterDelete` to produce audit events for every
+ * successful create, update, or delete operation.
+ *
+ * @example
+ * ```ts
+ * import { createAuditMiddleware } from "@spring-systems/core/middleware";
+ *
+ * // Send audit events to your backend:
+ * const unregister = createAuditMiddleware(async (event) => {
+ *     await fetch("/api/audit", {
+ *         method: "POST",
+ *         headers: { "Content-Type": "application/json" },
+ *         body: JSON.stringify(event),
+ *     });
+ * });
+ *
+ * // Or log to console during development:
+ * createAuditMiddleware((event) => {
+ *     console.log(`[Audit] ${event.action} ${event.entity}#${event.entityId}`, event);
+ * });
+ * ```
+ *
+ * @module audit-middleware
+ */
+
+interface AuditEvent {
+    /** Mutation type */
+    action: "create" | "update" | "delete";
+    /** Entity type name (e.g. "partner", "user") */
+    entity: string;
+    /** Entity record identifier */
+    entityId: string;
+    /** ISO 8601 timestamp of the event */
+    timestamp: string;
+    /** API endpoint URL used for the operation */
+    url: string;
+    /** Field values included in the save payload (empty object for deletes) */
+    fields: Record<string, unknown>;
+}
+type AuditEventHandler = (event: AuditEvent) => void | Promise<void>;
+/**
+ * Create and register audit middleware that emits `AuditEvent` for every
+ * successful form save (create or update) and delete operation.
+ *
+ * The middleware hooks into both `form:afterSave` and `form:afterDelete` slots.
+ * Aborted operations are silently skipped.
+ *
+ * @param handler - Callback that receives the audit event. Can be sync or async.
+ *                  Async errors are caught and logged to prevent audit failures
+ *                  from breaking the operation flow.
+ * @param options - Optional middleware options (e.g. `{ priority: 10 }`)
+ * @returns An unregister function that removes both audit middleware registrations.
+ */
+declare function createAuditMiddleware(handler: AuditEventHandler, options?: MiddlewareOptions): () => void;
+
+/**
+ * Koa-style middleware composition.
+ * Chains middleware functions with a `next()` pattern.
+ * @module middleware-runner
+ */
+
+interface ComposeOptions {
+    /**
+     * Optional timeout in milliseconds for the entire middleware chain.
+     * If the chain doesn't complete within this time, a SpringMiddlewareError is thrown.
+     * When omitted, no timeout is applied (backward-compatible default).
+     */
+    timeoutMs?: number;
+}
+/**
+ * Compose an array of middleware functions into a single function.
+ * Each middleware receives a context and a `next` callback.
+ * Calling `next()` invokes the next middleware in the chain.
+ * Calling `next()` more than once throws an error.
+ *
+ * @param middlewares - Array of middleware functions to compose
+ * @param options - Optional configuration (e.g. timeout)
+ * @returns A function that runs the full middleware chain on a given context.
+ */
+declare function composeMiddleware<TContext>(middlewares: ReadonlyArray<MiddlewareFn<TContext>>, options?: ComposeOptions): (ctx: TContext) => Promise<void>;
+
+export { type AuditEvent, type AuditEventHandler, type ComposeOptions, MiddlewareFn, MiddlewareOptions, composeMiddleware, createAuditMiddleware };

package/dist/middleware/index.js

@@ -0,0 +1,23 @@
+import {
+  createAuditMiddleware
+} from "../chunk-SQB4F3EF.js";
+import {
+  clearAllMiddleware,
+  composeMiddleware,
+  getMiddlewareRunner,
+  getRegisteredMiddlewareSlots,
+  registerMiddleware
+} from "../chunk-MEWPYTWC.js";
+import "../chunk-RUCXSQEY.js";
+import "../chunk-KX32MU3I.js";
+import "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+export {
+  clearAllMiddleware,
+  composeMiddleware,
+  createAuditMiddleware,
+  getMiddlewareRunner,
+  getRegisteredMiddlewareSlots,
+  registerMiddleware
+};
+//# sourceMappingURL=index.js.map

package/dist/middleware/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/middleware-registry-DT002qRd.d.ts

@@ -0,0 +1,60 @@
+import { M as MiddlewareSlot, a as MiddlewareFn } from './middleware-types-DVG9C1qJ.js';
+
+/**
+ * Middleware registry — manages middleware functions registered per slot.
+ *
+ * Type-safe: the context type is inferred from the slot name via MiddlewareSlotMap.
+ * Custom slots added via declaration merging also get full type inference.
+ *
+ * @module middleware-registry
+ */
+
+interface MiddlewareOptions {
+    /** Higher priority middleware runs first. Default: 0 */
+    priority?: number;
+}
+/**
+ * Register a middleware function for a given slot.
+ * The context type is automatically inferred from the slot name via MiddlewareSlotMap.
+ *
+ * @example
+ * ```ts
+ * // Context type is inferred as FormSaveContext
+ * const unregister = registerMiddleware("form:beforeSave", async (ctx, next) => {
+ *     console.log("Saving entity:", ctx.entity);
+ *     await next();
+ * });
+ * unregister(); // Cleanup when no longer needed
+ *
+ * // With priority (higher = runs first):
+ * registerMiddleware("form:beforeSave", auditMiddleware, { priority: 10 });
+ * ```
+ *
+ * @param slot - Middleware slot name (e.g. "form:beforeSave", "api:beforeRequest")
+ * @param middleware - Koa-style middleware function receiving `(ctx, next)`
+ * @param options - Optional settings; `priority` controls execution order (higher runs first, default 0)
+ * @returns An unregister function that removes this middleware from the slot.
+ */
+declare function registerMiddleware<TContext = unknown>(slot: MiddlewareSlot, middleware: MiddlewareFn<TContext>, options?: MiddlewareOptions): () => void;
+/**
+ * Get a composed runner for a given slot.
+ * Returns a function that executes all registered middleware for that slot
+ * in priority order (higher priority first) using the Koa-style `next()` pattern.
+ *
+ * If no middleware is registered for the slot, the returned function is a no-op.
+ *
+ * @param slot - Middleware slot name to compose a runner for
+ * @returns An async function that runs all middleware for the slot on a given context.
+ */
+declare function getMiddlewareRunner<TContext = unknown>(slot: MiddlewareSlot): (ctx: TContext) => Promise<void>;
+/**
+ * Get all slot names that have at least one middleware registered.
+ * Useful for debugging and introspection.
+ */
+declare function getRegisteredMiddlewareSlots(): MiddlewareSlot[];
+/**
+ * Remove all registered middleware. Intended for testing.
+ */
+declare function clearAllMiddleware(): void;
+
+export { type MiddlewareOptions as M, getRegisteredMiddlewareSlots as a, clearAllMiddleware as c, getMiddlewareRunner as g, registerMiddleware as r };

package/dist/middleware-types-DVG9C1qJ.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Middleware type definitions for form, list, and API operations.
+ *
+ * Middleware slots are extensible via declaration merging on MiddlewareSlotMap.
+ * Consumer projects and plugins can add custom slots:
+ *
+ * @example
+ * ```ts
+ * // In your plugin or consumer project:
+ * declare module "@spring-systems/core/middleware" {
+ *     interface MiddlewareSlotMap {
+ *         "custom:beforeExport": { format: string; data: unknown[] };
+ *         "custom:afterImport": { count: number; errors: string[] };
+ *     }
+ * }
+ * ```
+ *
+ * @module middleware-types
+ */
+type MiddlewareFn<TContext> = (ctx: TContext, next: () => Promise<void>) => Promise<void>;
+/** Internal entry stored in the registry — pairs a middleware function with its priority. */
+interface MiddlewareEntry<TContext = unknown> {
+    fn: MiddlewareFn<TContext>;
+    priority: number;
+}
+interface FormLoadContext {
+    entity: string;
+    id: string;
+    url: string;
+    data?: unknown;
+    aborted: boolean;
+    result?: unknown;
+}
+interface FormSaveContext {
+    entity: string;
+    id: string;
+    url: string;
+    fields: Record<string, unknown>;
+    isNew: boolean;
+    aborted: boolean;
+    result?: unknown;
+}
+interface FormDeleteContext {
+    entity: string;
+    id: string;
+    url: string;
+    aborted: boolean;
+    result?: unknown;
+}
+interface ListLoadContext {
+    apiUrl: string;
+    requestData: unknown;
+    aborted: boolean;
+    result?: unknown;
+}
+interface ApiRequestContext {
+    url: string;
+    method: string;
+    data?: unknown;
+    headers?: Record<string, string>;
+    aborted: boolean;
+    response?: unknown;
+    error?: unknown;
+}
+/**
+ * Extensible middleware slot map. Keys are slot names, values are context types.
+ * Extend via declaration merging to add custom slots.
+ */
+interface MiddlewareSlotMap {
+    "form:beforeLoad": FormLoadContext;
+    "form:afterLoad": FormLoadContext;
+    "form:beforeSave": FormSaveContext;
+    "form:afterSave": FormSaveContext;
+    "form:beforeDelete": FormDeleteContext;
+    "form:afterDelete": FormDeleteContext;
+    "list:beforeLoad": ListLoadContext;
+    "list:afterLoad": ListLoadContext;
+    "api:beforeRequest": ApiRequestContext;
+    "api:afterResponse": ApiRequestContext;
+    "api:onError": ApiRequestContext;
+}
+/** Union of all registered middleware slot names (auto-expands with declaration merging) */
+type MiddlewareSlot = keyof MiddlewareSlotMap;
+
+export type { ApiRequestContext as A, FormDeleteContext as F, ListLoadContext as L, MiddlewareSlot as M, MiddlewareFn as a, MiddlewareEntry as b, FormLoadContext as c, FormSaveContext as d, MiddlewareSlotMap as e };

package/dist/plugins/index.d.ts

@@ -0,0 +1,104 @@
+import { d as SpringInstance } from '../spring-instance-EbUh4mQb.js';
+import { a as FormDataValue, b as FormStoreState, c as ColumnType } from '../form-types-D3MdGpjA.js';
+import '../framework-config-types-DeUbx4bu.js';
+import '../middleware-types-DVG9C1qJ.js';
+import '../security-sanitize-Bb0PExM6.js';
+
+/**
+ * Plugin system for the SPRING framework.
+ *
+ * A plugin can be either:
+ * - A simple setup function (backward compatible): `(instance) => cleanup?`
+ * - A plugin descriptor with metadata: `{ name, version, setup, ... }`
+ *
+ * Plugin descriptors enable:
+ * - Dependency declaration and topological ordering
+ * - Capability requirements checking
+ * - Version compatibility validation
+ * - Plugin discovery and introspection
+ *
+ * @module plugin
+ */
+
+/** Column renderer info passed to custom renderers. */
+interface PluginColumnRendererInfo {
+    field: string;
+    type: ColumnType;
+    title: string;
+    suffix?: string;
+    decimals?: number;
+    name?: string;
+}
+/**
+ * Column renderer function signature.
+ * Returns a React node (any valid JSX return value).
+ */
+type PluginColumnRenderer = (value: FormDataValue, row: FormStoreState, column: PluginColumnRendererInfo) => unknown;
+/** Simple plugin function (backward compatible) */
+type SpringPluginFn = (instance: SpringInstance) => void | (() => void);
+/**
+ * Plugin descriptor with metadata for enterprise plugin management.
+ *
+ * @example
+ * ```ts
+ * const auditPlugin: SpringPluginDescriptor = {
+ *     name: "@spring-systems/audit",
+ *     version: "1.0.0",
+ *     requires: ["@spring-systems/core-validators"],
+ *     capabilities: ["advancedFiltering"],
+ *     setup(instance) {
+ *         registerMiddleware("form:beforeSave", auditMiddleware);
+ *         return () => { cleanup(); };
+ *     },
+ * };
+ * ```
+ */
+interface SpringPluginDescriptor {
+    /** Unique plugin name. Use npm-style scoped names (e.g. "@myorg/plugin-name"). */
+    name: string;
+    /** Semver version string. */
+    version?: string;
+    /** Names of plugins that must be loaded before this one. */
+    requires?: string[];
+    /** Capability keys that must be enabled for this plugin to activate. */
+    capabilities?: string[];
+    /** Plugin setup function. Returns optional cleanup. */
+    setup: SpringPluginFn;
+    /**
+     * Explicit cleanup function. Called by `disposePlugins()` alongside any
+     * cleanup returned from `setup()`. Also available for direct invocation
+     * by consumers who hold a reference to the descriptor.
+     */
+    cleanup?: () => void;
+}
+/** A SPRING plugin — either a simple function or a descriptor with metadata. */
+type SpringPlugin = SpringPluginFn | SpringPluginDescriptor;
+interface LoadedPluginInfo {
+    name: string;
+    version?: string;
+}
+/**
+ * Apply an array of plugins to a SpringInstance.
+ * Plugins with dependencies are topologically sorted.
+ * Each may return a cleanup function stored on the instance.
+ *
+ * Setup errors are caught and logged — a failing plugin does not block others.
+ *
+ * @param instance - The SpringInstance to apply plugins to
+ * @param plugins - Array of plugins (simple functions or descriptors with metadata)
+ */
+declare function applyPlugins(instance: SpringInstance, plugins: SpringPlugin[]): void;
+/**
+ * Run all cleanup functions stored by `applyPlugins()` and remove them
+ * from the instance. Errors during cleanup are caught and logged.
+ *
+ * @param instance - The SpringInstance whose plugins should be disposed
+ */
+declare function disposePlugins(instance: SpringInstance): void;
+/**
+ * Get the list of loaded plugins for the given instance.
+ * Useful for debugging and introspection.
+ */
+declare function getLoadedPlugins(instance: SpringInstance): ReadonlyArray<LoadedPluginInfo>;
+
+export { type PluginColumnRenderer, type PluginColumnRendererInfo, type SpringPlugin, type SpringPluginDescriptor, type SpringPluginFn, applyPlugins, disposePlugins, getLoadedPlugins };

package/dist/plugins/index.js

@@ -0,0 +1,16 @@
+import {
+  applyPlugins,
+  disposePlugins,
+  getLoadedPlugins
+} from "../chunk-GXU75LQX.js";
+import "../chunk-S7MKRNMI.js";
+import "../chunk-RUCXSQEY.js";
+import "../chunk-KX32MU3I.js";
+import "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+export {
+  applyPlugins,
+  disposePlugins,
+  getLoadedPlugins
+};
+//# sourceMappingURL=index.js.map

package/dist/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}