@spring-systems/core 0.8.0

package/dist/runtime-env-config-CajOEJCP.d.ts

@@ -0,0 +1,148 @@
+import { c as CapabilityMap, F as FrameworkConfigOverrides, a as FrameworkConfig } from './framework-config-types-DeUbx4bu.js';
+
+/**
+ * Feature capability system for enterprise SPRING deployments.
+ *
+ * Capabilities allow framework consumers to enable/disable features
+ * per client deployment. Plugins can declare required capabilities
+ * and the framework checks them at registration time.
+ *
+ * @example
+ * ```ts
+ * // In project-config.ts:
+ * configureCapabilities({
+ *     charts: true,
+ *     advancedFiltering: true,
+ *     bulkOperations: false,
+ *     export: { enabled: true, formats: ["xlsx", "pdf"] },
+ * });
+ *
+ * // In a plugin:
+ * if (hasCapability("advancedFiltering")) {
+ *     registerMiddleware("list:beforeLoad", advancedFilterMiddleware);
+ * }
+ *
+ * // In a component:
+ * const canExport = hasCapability("export");
+ * ```
+ *
+ * @module capabilities
+ */
+
+type CapabilityStore = Partial<CapabilityMap> & Record<string, unknown>;
+/**
+ * Configure feature capabilities for this deployment.
+ * Merges with existing capabilities (does not replace).
+ */
+declare function configureCapabilities(capabilities: Partial<CapabilityMap> & Record<string, unknown>): void;
+/**
+ * Check if a capability is enabled.
+ * Returns false for unknown/unconfigured capabilities.
+ */
+declare function hasCapability<K extends keyof CapabilityMap>(name: K): boolean;
+/**
+ * Get the full capability configuration for a feature.
+ * Returns undefined if the capability is not configured.
+ */
+declare function getCapability<K extends keyof CapabilityMap>(name: K): CapabilityMap[K] | undefined;
+/** Get all configured capabilities. */
+declare function getCapabilities(): Readonly<CapabilityStore>;
+/**
+ * Get the names of all currently registered (configured) capabilities.
+ * Useful for introspection and for validating that plugin capability
+ * references point to actually-configured features.
+ */
+declare function getRegisteredCapabilityNames(): string[];
+/** Reset all capabilities. For testing only. */
+declare function clearCapabilities(): void;
+
+/**
+ * Centralized framework configuration.
+ * Each project sets its own values via configureFramework().
+ * The framework reads from getFrameworkConfig().
+ * @module framework-config
+ */
+
+/**
+ * Default framework configuration. Exported as the single source of truth
+ * for both configureFramework() and createSpringInstance().
+ * Deep-frozen to prevent accidental mutation of shared defaults.
+ */
+declare const DEFAULT_FRAMEWORK_CONFIG: FrameworkConfig;
+interface ConfigValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validate a framework configuration and return structured results.
+ * Also callable standalone for CI/testing: `validateFrameworkConfig(config)`.
+ */
+declare function validateFrameworkConfig(cfg: FrameworkConfig): ConfigValidationResult;
+declare function createFrameworkConfig(overrides?: FrameworkConfigOverrides): FrameworkConfig;
+declare function configureFramework(overrides: FrameworkConfigOverrides): void;
+declare function getFrameworkConfig(): FrameworkConfig;
+/**
+ * Reset framework config to immutable defaults.
+ * Intended for test/integration teardown.
+ */
+declare function clearFrameworkConfig(): void;
+/** Max file size for upload — reads from framework config limits.maxFileSize */
+declare function getMaxFileSize(): number;
+/** Debounce delay for autocomplete search — reads from framework config limits.autocompleteDebounceMs */
+declare function getAutocompleteDebounceMs(): number;
+/** Idle timeout for SignalR hub disconnect — reads from framework config limits.signalrIdleTimeoutMs */
+declare function getSignalrIdleTimeoutMs(): number;
+/** SignalR server timeout — reads from framework config limits.signalrServerTimeoutMs */
+declare function getSignalrServerTimeoutMs(): number;
+/** SignalR keep-alive interval — reads from framework config limits.signalrKeepAliveIntervalMs */
+declare function getSignalrKeepAliveIntervalMs(): number;
+/** SignalR reconnect delay sequence — reads from framework config limits.signalrReconnectDelaysMs */
+declare function getSignalrReconnectDelaysMs(): readonly number[];
+/** Idle session timeout — reads from framework config limits.idleSessionTimeoutMs */
+declare function getIdleSessionTimeoutMs(): number;
+/** API request timeout — reads from framework config api.timeoutMs */
+declare function getApiTimeoutMs(): number;
+/** Default list page size — reads from framework config api.defaultPageSize */
+declare function getApiDefaultPageSize(): number;
+declare function getSessionCookieName(prefix: string): string;
+declare function getSecureSessionCookieName(prefix: string): string;
+/**
+ * Apply the fallback config to a SpringInstance.
+ * Called by SpringProvider after instance creation to pick up early configureFramework() calls.
+ */
+declare function applyFallbackConfig(instance: {
+    core: {
+        config: FrameworkConfig;
+    };
+}): void;
+
+/**
+ * Runtime environment variable keys injected on the client.
+ * Values are read from `window.__RUNTIME_ENV__`.
+ *
+ * Consumers can register additional keys via `registerRuntimeEnvKeys()`.
+ * @module runtime-env-config
+ */
+/** Default framework runtime env keys. */
+declare const RUNTIME_ENV_KEYS: readonly ["IMAGE_TAG", "ENVIRONMENT", "BUILD_NUM", "BUILD_DATE"];
+type RuntimeEnvKey = (typeof RUNTIME_ENV_KEYS)[number];
+type RuntimeEnv = Partial<Record<string, string>>;
+/**
+ * Register additional runtime environment keys.
+ * Call this before runtime env payload is consumed by the app bootstrap.
+ */
+declare function registerRuntimeEnvKeys(...keys: string[]): void;
+/** Returns all registered runtime env keys (defaults + consumer-registered). */
+declare function getRuntimeEnvKeys(): readonly string[];
+/** Clear consumer-registered runtime env keys. For testing only. */
+declare function clearRuntimeEnvKeys(): void;
+declare global {
+    interface Window {
+        __RUNTIME_ENV__?: RuntimeEnv;
+    }
+}
+declare function getRuntimeVar(key: string): string;
+declare function getImageTag(): string;
+
+export { getSignalrReconnectDelaysMs as A, getSignalrServerTimeoutMs as B, type ConfigValidationResult as C, DEFAULT_FRAMEWORK_CONFIG as D, registerRuntimeEnvKeys as E, validateFrameworkConfig as F, RUNTIME_ENV_KEYS as R, configureFramework as a, getCapability as b, configureCapabilities as c, getFrameworkConfig as d, type RuntimeEnv as e, type RuntimeEnvKey as f, getCapabilities as g, hasCapability as h, applyFallbackConfig as i, clearCapabilities as j, clearFrameworkConfig as k, clearRuntimeEnvKeys as l, createFrameworkConfig as m, getApiDefaultPageSize as n, getApiTimeoutMs as o, getAutocompleteDebounceMs as p, getIdleSessionTimeoutMs as q, getImageTag as r, getMaxFileSize as s, getRegisteredCapabilityNames as t, getRuntimeEnvKeys as u, getRuntimeVar as v, getSecureSessionCookieName as w, getSessionCookieName as x, getSignalrIdleTimeoutMs as y, getSignalrKeepAliveIntervalMs as z };

package/dist/security-sanitize-Bb0PExM6.d.ts

@@ -0,0 +1,9 @@
+type SecurityLogScalar = string | number | boolean | null;
+interface SecurityLogData {
+    [key: string]: SecurityLogValue;
+}
+type SecurityLogValue = SecurityLogScalar | SecurityLogData | SecurityLogValue[];
+declare function isSensitiveSecurityKey(key: string): boolean;
+declare function sanitizeSecurityData(data?: SecurityLogData): SecurityLogData | undefined;
+
+export { type SecurityLogData as S, type SecurityLogScalar as a, type SecurityLogValue as b, isSensitiveSecurityKey as i, sanitizeSecurityData as s };

package/dist/spring-instance-EbUh4mQb.d.ts

@@ -0,0 +1,119 @@
+import { a as FrameworkConfig } from './framework-config-types-DeUbx4bu.js';
+import { M as MiddlewareSlot, b as MiddlewareEntry } from './middleware-types-DVG9C1qJ.js';
+import { V as ValidatorFn } from './form-types-D3MdGpjA.js';
+import { S as SecurityLogData } from './security-sanitize-Bb0PExM6.js';
+
+/**
+ * SpringInstance — central state container for the SPRING framework.
+ * Replaces module-level singletons with a per-instance state tree.
+ *
+ * IMPORTANT: This file imports only from type-only or non-circular modules.
+ * Type imports from config/framework-config-types.ts are safe (pure type file).
+ * @module spring-instance
+ */
+
+/** Content resolution adapter (i18n) */
+interface InstanceContentAdapter {
+    getRes(key: string): string;
+}
+/** Notification adapter (toast/snackbar) */
+interface InstanceNotificationAdapter {
+    error(msg: string): void;
+    success(msg: string): void;
+    warning(msg: string): void;
+    info(msg: string): void;
+}
+/** Security event types emitted by the framework. Extensible via `string & {}`. */
+type SecurityEventType = "login" | "logout" | "password_change" | "session_timeout" | "rate_limit_exceeded" | "auth_failed" | "session_expired" | "csrf_mismatch" | "token_refresh_failed" | (string & {});
+/** Log adapter (error/warn/security) */
+type BivariantCallback<TArgs extends unknown[], TResult = void> = {
+    bivarianceHack: (...args: TArgs) => TResult;
+}["bivarianceHack"];
+interface InstanceLogAdapter {
+    onError?: (context: string, error?: unknown) => void;
+    onWarn?: (context: string, message?: string) => void;
+    onSecurityEvent?: BivariantCallback<[event: SecurityEventType, data?: SecurityLogData]>;
+}
+/**
+ * Instance lifecycle state.
+ * - `creating`: Instance is being constructed (before init)
+ * - `ready`: Instance is fully initialized and operational
+ * - `disposing`: Instance is in cleanup process
+ * - `disposed`: Instance has been disposed and should not be used
+ */
+type InstanceLifecycleState = "creating" | "ready" | "disposing" | "disposed";
+/** Built-in logout reasons. Extensible via `string &amp; {}` to allow custom reasons from plugins. */
+type LogoutReason = "unauthorized" | "proxy_error" | "token_missing" | "manual" | (string & {});
+type LogoutHandler = (reason: LogoutReason) => void | Promise<void>;
+type EventHandler<T = unknown> = (payload: T) => void | Promise<void>;
+interface HandlerEntry<T = unknown> {
+    handler: EventHandler<T>;
+    once: boolean;
+}
+interface RequestHook {
+    (url: string, config: {
+        method: string;
+        headers: Record<string, string>;
+    }): void;
+}
+interface ResponseHook {
+    (url: string, status: number, data: unknown): void;
+}
+/**
+ * Extensible UI state interface for SpringInstance.
+ * Plugins and packages can extend this via declaration merging:
+ *
+ * @example
+ * ```ts
+ * declare module "@spring-systems/core/instance" {
+ *     interface SpringUIState {
+ *         myPlugin: { count: number };
+ *     }
+ * }
+ * ```
+ *
+ * The base interface includes an index signature to support dynamic
+ * registry keys (slots, renderers, etc.) stored with string/symbol keys.
+ */
+interface SpringUIState {
+    [key: string | symbol]: unknown;
+}
+/** Core framework state — config, adapters, logging, auth, middleware, validation */
+interface SpringCoreState {
+    /** Framework configuration — fully typed via FrameworkConfig from framework-config-types.ts */
+    config: FrameworkConfig;
+    contentAdapter: InstanceContentAdapter;
+    notificationAdapter: InstanceNotificationAdapter;
+    logAdapter: InstanceLogAdapter;
+    logoutHandler: LogoutHandler | null;
+    authenticated: boolean;
+    logoutInFlight: Promise<void> | null;
+    /** Event bus listeners map — keyed by event name. Readonly ref — mutate contents via Map methods, never reassign. */
+    readonly eventListeners: Map<string, HandlerEntry[]>;
+    readonly middlewareRegistry: Map<MiddlewareSlot, MiddlewareEntry<any>[]>;
+    readonly validatorRegistry: Map<string, ValidatorFn>;
+}
+/** API client state — auth tokens, request tracking, hooks */
+interface SpringApiState {
+    authToken: string | null;
+    /** Readonly ref — mutate contents via Set methods, never reassign. */
+    readonly requestControllers: Set<AbortController>;
+    requestHook: RequestHook | null;
+    responseHook: ResponseHook | null;
+    apiPrefix: string;
+    sessionExpiredCodes: Set<string> | undefined;
+}
+/** Central framework instance. All mutable state lives here. */
+interface SpringInstance {
+    readonly id: string;
+    /** Current lifecycle state of this instance */
+    readonly state: InstanceLifecycleState;
+    readonly core: SpringCoreState;
+    readonly api: SpringApiState;
+    /** Extensible UI state — plugins extend via declaration merging on SpringUIState */
+    readonly ui: SpringUIState;
+    /** Dispose this instance — clears all state, aborts requests, runs plugin cleanups */
+    dispose(): void;
+}
+
+export type { HandlerEntry as H, InstanceContentAdapter as I, LogoutHandler as L, RequestHook as R, SecurityEventType as S, LogoutReason as a, InstanceNotificationAdapter as b, InstanceLogAdapter as c, SpringInstance as d, InstanceLifecycleState as e, ResponseHook as f, SpringApiState as g, SpringCoreState as h, SpringUIState as i };

package/dist/testing/index.d.ts

@@ -0,0 +1,129 @@
+import { F as FrameworkConfigOverrides } from '../framework-config-types-DeUbx4bu.js';
+import { I as InstanceContentAdapter, b as InstanceNotificationAdapter, c as InstanceLogAdapter, d as SpringInstance } from '../spring-instance-EbUh4mQb.js';
+import { SpringPlugin } from '../plugins/index.js';
+import { S as SecurityLogData } from '../security-sanitize-Bb0PExM6.js';
+import '../middleware-types-DVG9C1qJ.js';
+import '../form-types-D3MdGpjA.js';
+
+/**
+ * Testing utilities for SPRING framework consumers and plugin authors.
+ *
+ * Provides factory functions to create isolated SpringInstances for tests
+ * with pre-configured mocks and adapters.
+ *
+ * @example
+ * ```ts
+ * import { createTestInstance, mockAdapters } from "@spring-systems/core/testing";
+ *
+ * describe("my plugin", () => {
+ *     let instance: SpringInstance;
+ *
+ *     beforeEach(() => {
+ *         instance = createTestInstance({
+ *             config: { app: { name: "Test" } },
+ *             plugins: [myPlugin],
+ *         });
+ *     });
+ *
+ *     afterEach(() => {
+ *         instance.dispose();
+ *     });
+ *
+ *     it("registers middleware", () => {
+ *         expect(getMiddlewareRunner("form:beforeSave")).toBeDefined();
+ *     });
+ * });
+ * ```
+ *
+ * @module test-utils
+ */
+
+interface CreateTestInstanceOptions {
+    /** Framework config overrides for this test instance */
+    config?: FrameworkConfigOverrides;
+    /** Plugins to apply to the test instance */
+    plugins?: SpringPlugin[];
+    /** Whether to set this as the global current instance (default: true) */
+    setGlobal?: boolean;
+    /** Custom content adapter (defaults to identity function) */
+    contentAdapter?: InstanceContentAdapter;
+    /** Custom notification adapter (defaults to no-op) */
+    notificationAdapter?: InstanceNotificationAdapter;
+    /** Custom log adapter (defaults to no-op) */
+    logAdapter?: InstanceLogAdapter;
+}
+/**
+ * Create an isolated SpringInstance for testing.
+ * Automatically sets it as the global current instance (unless setGlobal: false).
+ * Call `instance.dispose()` in afterEach to clean up.
+ */
+declare function createTestInstance(options?: CreateTestInstanceOptions): SpringInstance;
+/** Pre-built mock adapters for testing */
+declare const mockAdapters: {
+    /** Content adapter that returns the key itself (identity) */
+    readonly content: () => InstanceContentAdapter;
+    /** Content adapter that returns a custom mapping */
+    readonly contentWithMessages: (messages: Record<string, string>) => InstanceContentAdapter;
+    /** Notification adapter that collects all notifications for assertions */
+    readonly notificationCollector: () => {
+        adapter: {
+            error: (msg: string) => number;
+            success: (msg: string) => number;
+            warning: (msg: string) => number;
+            info: (msg: string) => number;
+        };
+        calls: {
+            type: "error" | "success" | "warning" | "info";
+            msg: string;
+        }[];
+        clear: () => void;
+    };
+    /** Log adapter that collects all log entries for assertions */
+    readonly logCollector: () => {
+        adapter: {
+            onError: (ctx: string, err?: unknown) => number;
+            onWarn: (ctx: string, msg?: string) => number;
+            onSecurityEvent: (evt: unknown, data?: SecurityLogData) => number;
+        };
+        errors: {
+            context: string;
+            error?: unknown;
+        }[];
+        warnings: {
+            context: string;
+            message?: string;
+        }[];
+        securityEvents: {
+            event: unknown;
+            data?: SecurityLogData;
+        }[];
+    };
+    /** Silent no-op adapters (suppress all output) */
+    readonly silent: {
+        readonly content: {
+            getRes: (key: string) => string;
+        };
+        readonly notification: {
+            error: (_msg: string) => void;
+            success: (_msg: string) => void;
+            warning: (_msg: string) => void;
+            info: (_msg: string) => void;
+        };
+        readonly log: {};
+    };
+};
+/** Boundary cast for tests — replaces the `as unknown as X` pattern in a single place.
+ * Usage: `castTo<FormStoreApi>({ getState: vi.fn() })` instead of `{ getState: vi.fn() } as unknown as FormStoreApi`
+ */
+declare function castTo<T>(value: unknown): T;
+/** Runtime assertion that a value is defined. Returns the value with a non-nullable type.
+ * Usage: `assertDefined(arr[0]).field` instead of `arr[0]!.field`
+ */
+declare function assertDefined<T>(val: T | undefined | null, msg?: string): T;
+/**
+ * Resets singleton/fallback runtime state across core modules.
+ * Useful in integration tests that run multiple app lifecycles in one process.
+ */
+declare function resetCoreRuntimeState(): void;
+
+export { type CreateTestInstanceOptions, assertDefined, castTo, createTestInstance, mockAdapters, resetCoreRuntimeState };

package/dist/testing/index.js

@@ -0,0 +1,171 @@
+import {
+  createSpringInstance
+} from "../chunk-F2SIMWZ5.js";
+import {
+  applyPlugins,
+  disposePlugins
+} from "../chunk-GXU75LQX.js";
+import {
+  eventBus
+} from "../chunk-OSSX443T.js";
+import {
+  clearAllMiddleware
+} from "../chunk-MEWPYTWC.js";
+import {
+  clearRuntimeEnvKeys
+} from "../chunk-UDT2RPX2.js";
+import {
+  clearCapabilities
+} from "../chunk-S7MKRNMI.js";
+import {
+  clearFrameworkConfig
+} from "../chunk-F7WUQJH7.js";
+import {
+  clearValidators
+} from "../chunk-RRWKDFAB.js";
+import "../chunk-QAVWXARR.js";
+import {
+  clearAuthState
+} from "../chunk-HFELOXDQ.js";
+import {
+  clearHttpAdapter,
+  clearLicenseAdapter,
+  clearNotificationAdapter
+} from "../chunk-GON7Q32Q.js";
+import {
+  clearTelemetryAdapter
+} from "../chunk-S6RPCN5H.js";
+import {
+  clearContentAdapter
+} from "../chunk-NQQIVCLX.js";
+import "../chunk-N2L4TUC4.js";
+import "../chunk-RUCXSQEY.js";
+import {
+  clearLogAdapter,
+  resetLogLevel
+} from "../chunk-KX32MU3I.js";
+import {
+  clearSpringInstance,
+  setSpringInstance
+} from "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+
+// src/testing/test-utils.ts
+function createTestInstance(options = {}) {
+  const instance = createSpringInstance(options.config);
+  if (options.contentAdapter) {
+    instance.core.contentAdapter = options.contentAdapter;
+  }
+  if (options.notificationAdapter) {
+    instance.core.notificationAdapter = options.notificationAdapter;
+  }
+  if (options.logAdapter) {
+    instance.core.logAdapter = options.logAdapter;
+  }
+  if (options.setGlobal !== false) {
+    setSpringInstance(instance);
+  }
+  if (options.plugins && options.plugins.length > 0) {
+    applyPlugins(instance, options.plugins);
+  }
+  const originalDispose = instance.dispose.bind(instance);
+  instance.dispose = () => {
+    disposePlugins(instance);
+    originalDispose();
+    if (options.setGlobal !== false) {
+      clearSpringInstance();
+    }
+  };
+  return instance;
+}
+var mockAdapters = {
+  /** Content adapter that returns the key itself (identity) */
+  content: () => ({
+    getRes: (key) => key
+  }),
+  /** Content adapter that returns a custom mapping */
+  contentWithMessages: (messages) => ({
+    getRes: (key) => messages[key] ?? `[${key}]`
+  }),
+  /** Notification adapter that collects all notifications for assertions */
+  notificationCollector: () => {
+    const calls = [];
+    return {
+      adapter: {
+        error: (msg) => calls.push({ type: "error", msg }),
+        success: (msg) => calls.push({ type: "success", msg }),
+        warning: (msg) => calls.push({ type: "warning", msg }),
+        info: (msg) => calls.push({ type: "info", msg })
+      },
+      calls,
+      clear: () => {
+        calls.length = 0;
+      }
+    };
+  },
+  /** Log adapter that collects all log entries for assertions */
+  logCollector: () => {
+    const errors = [];
+    const warnings = [];
+    const securityEvents = [];
+    return {
+      adapter: {
+        onError: (ctx, err) => errors.push({ context: ctx, error: err }),
+        onWarn: (ctx, msg) => warnings.push({ context: ctx, message: msg }),
+        onSecurityEvent: (evt, data) => securityEvents.push({ event: evt, data })
+      },
+      errors,
+      warnings,
+      securityEvents
+    };
+  },
+  /** Silent no-op adapters (suppress all output) */
+  silent: {
+    content: { getRes: (key) => key },
+    notification: {
+      error: (_msg) => {
+      },
+      success: (_msg) => {
+      },
+      warning: (_msg) => {
+      },
+      info: (_msg) => {
+      }
+    },
+    log: {}
+  }
+};
+function castTo(value) {
+  return value;
+}
+function assertDefined(val, msg) {
+  if (val === void 0 || val === null) {
+    throw new Error(msg ?? "Expected value to be defined, but got " + String(val));
+  }
+  return val;
+}
+function resetCoreRuntimeState() {
+  eventBus.clearAll();
+  clearAllMiddleware();
+  clearValidators();
+  clearCapabilities();
+  clearFrameworkConfig();
+  clearRuntimeEnvKeys();
+  clearAuthState();
+  clearContentAdapter();
+  clearNotificationAdapter();
+  clearHttpAdapter();
+  clearLicenseAdapter();
+  clearTelemetryAdapter();
+  clearLogAdapter();
+  resetLogLevel();
+  clearSpringInstance();
+}
+export {
+  assertDefined,
+  castTo,
+  createTestInstance,
+  mockAdapters,
+  resetCoreRuntimeState
+};
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/testing/test-utils.ts"],"sourcesContent":["/**\n * Testing utilities for SPRING framework consumers and plugin authors.\n *\n * Provides factory functions to create isolated SpringInstances for tests\n * with pre-configured mocks and adapters.\n *\n * @example\n * ```ts\n * import { createTestInstance, mockAdapters } from \"@spring-systems/core/testing\";\n *\n * describe(\"my plugin\", () => {\n *     let instance: SpringInstance;\n *\n *     beforeEach(() => {\n *         instance = createTestInstance({\n *             config: { app: { name: \"Test\" } },\n *             plugins: [myPlugin],\n *         });\n *     });\n *\n *     afterEach(() => {\n *         instance.dispose();\n *     });\n *\n *     it(\"registers middleware\", () => {\n *         expect(getMiddlewareRunner(\"form:beforeSave\")).toBeDefined();\n *     });\n * });\n * ```\n *\n * @module test-utils\n */\n\nimport {\n    clearContentAdapter,\n    clearHttpAdapter,\n    clearLicenseAdapter,\n    clearNotificationAdapter,\n    clearTelemetryAdapter,\n} from \"../adapters\";\nimport { clearAuthState } from \"../auth/auth-handler\";\nimport { clearCapabilities } from \"../config/capabilities\";\nimport { clearFrameworkConfig } from \"../config/framework-config\";\nimport type { FrameworkConfigOverrides } from \"../config/framework-config-types\";\nimport { clearRuntimeEnvKeys } from \"../config/runtime-env-config\";\nimport { eventBus } from \"../events/event-bus\";\nimport { createSpringInstance } from \"../instance/create-instance\";\nimport { clearSpringInstance,setSpringInstance } from \"../instance/current-instance\";\nimport type { InstanceContentAdapter, InstanceLogAdapter,InstanceNotificationAdapter,SpringInstance } from \"../instance/spring-instance\";\nimport { clearLogAdapter, resetLogLevel } from \"../logger/logger\";\nimport { clearAllMiddleware } from \"../middleware/middleware-registry\";\nimport type { SpringPlugin } from \"../plugins/plugin\";\nimport { applyPlugins, disposePlugins } from \"../plugins/plugin\";\nimport type { SecurityLogData } from \"../utils/security-sanitize\";\nimport { clearValidators } from \"../validation/validations\";\n\nexport interface CreateTestInstanceOptions {\n    /** Framework config overrides for this test instance */\n    config?: FrameworkConfigOverrides;\n    /** Plugins to apply to the test instance */\n    plugins?: SpringPlugin[];\n    /** Whether to set this as the global current instance (default: true) */\n    setGlobal?: boolean;\n    /** Custom content adapter (defaults to identity function) */\n    contentAdapter?: InstanceContentAdapter;\n    /** Custom notification adapter (defaults to no-op) */\n    notificationAdapter?: InstanceNotificationAdapter;\n    /** Custom log adapter (defaults to no-op) */\n    logAdapter?: InstanceLogAdapter;\n}\n\n/**\n * Create an isolated SpringInstance for testing.\n * Automatically sets it as the global current instance (unless setGlobal: false).\n * Call `instance.dispose()` in afterEach to clean up.\n */\nexport function createTestInstance(options: CreateTestInstanceOptions = {}): SpringInstance {\n    const instance = createSpringInstance(options.config);\n\n    // Apply mock adapters\n    if (options.contentAdapter) {\n        instance.core.contentAdapter = options.contentAdapter;\n    }\n    if (options.notificationAdapter) {\n        instance.core.notificationAdapter = options.notificationAdapter;\n    }\n    if (options.logAdapter) {\n        instance.core.logAdapter = options.logAdapter;\n    }\n\n    // Set as global if requested\n    if (options.setGlobal !== false) {\n        setSpringInstance(instance);\n    }\n\n    // Apply plugins\n    if (options.plugins && options.plugins.length > 0) {\n        applyPlugins(instance, options.plugins);\n    }\n\n    // Augment dispose to also clear global and dispose plugins\n    const originalDispose = instance.dispose.bind(instance);\n    instance.dispose = () => {\n        disposePlugins(instance);\n        originalDispose();\n        if (options.setGlobal !== false) {\n            clearSpringInstance();\n        }\n    };\n\n    return instance;\n}\n\n/** Pre-built mock adapters for testing */\nexport const mockAdapters = {\n    /** Content adapter that returns the key itself (identity) */\n    content: (): InstanceContentAdapter => ({\n        getRes: (key: string) => key,\n    }),\n\n    /** Content adapter that returns a custom mapping */\n    contentWithMessages: (messages: Record<string, string>): InstanceContentAdapter => ({\n        getRes: (key: string) => messages[key] ?? `[${key}]`,\n    }),\n\n    /** Notification adapter that collects all notifications for assertions */\n    notificationCollector: () => {\n        const calls: Array<{ type: \"error\" | \"success\" | \"warning\" | \"info\"; msg: string }> = [];\n        return {\n            adapter: {\n                error: (msg: string) => calls.push({ type: \"error\", msg }),\n                success: (msg: string) => calls.push({ type: \"success\", msg }),\n                warning: (msg: string) => calls.push({ type: \"warning\", msg }),\n                info: (msg: string) => calls.push({ type: \"info\", msg }),\n            } satisfies InstanceNotificationAdapter,\n            calls,\n            clear: () => { calls.length = 0; },\n        };\n    },\n\n    /** Log adapter that collects all log entries for assertions */\n    logCollector: () => {\n        const errors: Array<{ context: string; error?: unknown }> = [];\n        const warnings: Array<{ context: string; message?: string }> = [];\n        const securityEvents: Array<{ event: unknown; data?: SecurityLogData }> = [];\n        return {\n            adapter: {\n                onError: (ctx: string, err?: unknown) => errors.push({ context: ctx, error: err }),\n                onWarn: (ctx: string, msg?: string) => warnings.push({ context: ctx, message: msg }),\n                onSecurityEvent: (evt: unknown, data?: SecurityLogData) => securityEvents.push({ event: evt, data }),\n            } satisfies InstanceLogAdapter,\n            errors,\n            warnings,\n            securityEvents,\n        };\n    },\n\n    /** Silent no-op adapters (suppress all output) */\n    silent: {\n        content: { getRes: (key: string) => key } satisfies InstanceContentAdapter,\n        notification: {\n            error: (_msg: string) => {},\n            success: (_msg: string) => {},\n            warning: (_msg: string) => {},\n            info: (_msg: string) => {},\n        } satisfies InstanceNotificationAdapter,\n        log: {} satisfies InstanceLogAdapter,\n    },\n} as const;\n\n/** Boundary cast for tests — replaces the `as unknown as X` pattern in a single place.\n * Usage: `castTo<FormStoreApi>({ getState: vi.fn() })` instead of `{ getState: vi.fn() } as unknown as FormStoreApi`\n */\nexport function castTo<T>(value: unknown): T {\n    return value as T;\n}\n\n/** Runtime assertion that a value is defined. Returns the value with a non-nullable type.\n * Usage: `assertDefined(arr[0]).field` instead of `arr[0]!.field`\n */\nexport function assertDefined<T>(val: T | undefined | null, msg?: string): T {\n    if (val === undefined || val === null) {\n        throw new Error(msg ?? \"Expected value to be defined, but got \" + String(val));\n    }\n    return val;\n}\n\n/**\n * Resets singleton/fallback runtime state across core modules.\n * Useful in integration tests that run multiple app lifecycles in one process.\n */\nexport function resetCoreRuntimeState(): void {\n    eventBus.clearAll();\n    clearAllMiddleware();\n    clearValidators();\n    clearCapabilities();\n    clearFrameworkConfig();\n    clearRuntimeEnvKeys();\n\n    clearAuthState();\n    clearContentAdapter();\n    clearNotificationAdapter();\n    clearHttpAdapter();\n    clearLicenseAdapter();\n    clearTelemetryAdapter();\n    clearLogAdapter();\n    resetLogLevel();\n\n    clearSpringInstance();\n}\n"],"mappings":"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","names":[]}