@spring-systems/core 0.8.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# @spring-systems/core
+
+## 0.7.5
+
+### Patch Changes
+
+- Version bump for aligned release across all packages.
+
+## 0.7.4
+
+### Patch Changes
+
+- Dependency updates and version alignment.
+
+## 0.7.3
+
+## 0.7.2
+
+### Patch Changes
+
+- Improve package documentation, onboarding navigation, and npm-published docs coverage.
+
+## 0.7.1
+
+### Patch Changes
+
+- Align package documentation with repository docs and enforce docs quality checks in release workflow.
+
+## 0.7.0
+
+### Patch Changes
+
+- Initial npm registry release

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2024-2026 The Authors
+
+All rights reserved.
+
+This software and associated documentation are proprietary and confidential.
+No rights are granted except as expressly agreed in writing by the copyright holder(s).
+Use, copying, modification, distribution, sublicensing, publication, or disclosure
+without prior written permission is prohibited.

package/README.md

@@ -0,0 +1,77 @@
+# @spring-systems/core
+
+Core types, utilities, configuration, and runtime primitives for the Spring Systems SPRING framework. This package is intentionally React-free and exists to hold the shared contracts the rest of the stack builds on.
+
+## When To Use It
+
+Choose this package when the concern belongs to framework runtime rather than rendered UI.
+
+- use it for configuration, instance lifecycle, events, middleware, plugins, validation, shared types, and utilities
+- skip it for page rendering, browser-only component state, or Next.js request handling
+
+## Install
+
+```bash
+pnpm add @spring-systems/core
+```
+
+This package has minimal dependencies (`dayjs`, `sanitize-html`) and no peer dependencies.
+
+## Quick Start
+
+```ts
+import { createSpringInstance, markInstanceReady } from "@spring-systems/core/instance";
+import { eventBus } from "@spring-systems/core/events";
+import { registerMiddleware } from "@spring-systems/core/middleware";
+
+const instance = createSpringInstance({
+    app: { name: "My SPRING", defaultRoute: "/" },
+    auth: { sessionCookiePrefix: "myspring" },
+});
+
+eventBus.on("auth:logout", () => console.log("User logged out"));
+
+registerMiddleware("form:beforeSave", async (ctx, next) => {
+    console.log("Saving:", ctx);
+    await next();
+});
+
+markInstanceReady(instance);
+```
+
+## Entry Points
+
+| Import path | Use it for |
+|---|---|
+| `@spring-systems/core` | Convenience re-exports |
+| `@spring-systems/core/config` | Framework configuration and theme tokens |
+| `@spring-systems/core/instance` | `SpringInstance` factory and lifecycle |
+| `@spring-systems/core/events` | Typed event bus |
+| `@spring-systems/core/middleware` | Middleware registry and runner |
+| `@spring-systems/core/plugins` | Plugin setup and disposal |
+| `@spring-systems/core/validation` | Field validators and registry |
+| `@spring-systems/core/auth` | Auth state helpers |
+| `@spring-systems/core/adapters` | Adapter interfaces |
+| `@spring-systems/core/logger` | Logging facade |
+| `@spring-systems/core/utils` | Shared utilities |
+| `@spring-systems/core/types` | Shared type definitions |
+| `@spring-systems/core/errors` | Error types |
+| `@spring-systems/core/i18n` | Default i18n messages |
+| `@spring-systems/core/testing` | Test helpers |
+| `@spring-systems/core/devtools` | Instance inspection helpers |
+
+## Boundary Rules
+
+- do not treat `SpringInstance` as a replacement for screen-local state
+- if code needs React rendering or component composition, it likely belongs in `ui`
+- if code needs the Next.js server boundary, it belongs in `server`
+- for deeper ownership decisions see [ARCHITECTURE.md](https://bitbucket.org/springsystems-projects/spring-framework-frontend/blob/main/docs/ARCHITECTURE.md) in the monorepo docs
+- for extension design see [EXTENSIBILITY_COOKBOOK.md](https://bitbucket.org/springsystems-projects/spring-framework-frontend/blob/main/docs/EXTENSIBILITY_COOKBOOK.md) in the monorepo docs
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history and breaking changes.
+
+## License
+
+UNLICENSED

package/dist/adapters/index.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Content adapter — decouples API/validation layers from the i18n system (contents store).
+ * Pattern matches setLogAdapter() in logger.ts.
+ * @module content-adapter
+ */
+interface ContentAdapter {
+    getRes(key: string): string;
+}
+declare function setContentAdapter(adapter: ContentAdapter): void;
+/** Returns translated content via the registered adapter. Replaces direct getRes() imports in core/api layers. */
+declare function getContentRes(key: string): string;
+/** Reset to default content adapter. For testing/integration teardown only. */
+declare function clearContentAdapter(): void;
+
+/**
+ * HTTP adapter — decouples the framework from any specific HTTP client (axios, fetch, etc.).
+ *
+ * Consumer applications provide their own HTTP implementation by setting a custom adapter.
+ * The framework uses this adapter for all API communication (lists, forms, auth, etc.)
+ *
+ * @example
+ * ```ts
+ * import { setHttpAdapter } from "@spring-systems/core/adapters";
+ *
+ * setHttpAdapter({
+ *     async request(config) {
+ *         const resp = await fetch(config.url, {
+ *             method: config.method ?? "GET",
+ *             body: config.data ? JSON.stringify(config.data) : undefined,
+ *             headers: config.headers,
+ *             signal: config.signal,
+ *         });
+ *         return resp.json();
+ *     },
+ *     async get(url, config) {
+ *         return this.request({ ...config, url, method: "GET" });
+ *     },
+ *     async post(config) {
+ *         return this.request({ ...config, method: "POST" });
+ *     },
+ *     async put(config) {
+ *         return this.request({ ...config, method: "PUT" });
+ *     },
+ *     async delete(url, config) {
+ *         return this.request({ ...config, url, method: "DELETE" });
+ *     },
+ * });
+ * ```
+ *
+ * @module http-adapter
+ */
+interface HttpRequest {
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    data?: unknown;
+    params?: Record<string, string>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    /** Override the global timeout for this request (e.g. longer timeout for exports/uploads). */
+    timeoutMs?: number;
+    suppressToast?: boolean;
+    suppressRedirect?: boolean;
+}
+interface HttpAdapter {
+    request<TResponse>(config: HttpRequest): Promise<TResponse | undefined>;
+    get<TResponse>(url: string, config?: Partial<HttpRequest>): Promise<TResponse | undefined>;
+    post<TData, TResponse>(config: HttpRequest & {
+        data: TData;
+    }): Promise<TResponse | undefined>;
+    put<TData, TResponse>(config: HttpRequest & {
+        data: TData;
+    }): Promise<TResponse | undefined>;
+    delete<TResponse>(url: string, config?: Partial<HttpRequest>): Promise<TResponse | undefined>;
+}
+declare function setHttpAdapter(adapter: HttpAdapter): void;
+declare function getHttpAdapter(): HttpAdapter;
+/**
+ * Reset the HTTP adapter to the default noop adapter.
+ * For testing only.
+ */
+declare function clearHttpAdapter(): void;
+
+/**
+ * License adapter — provides a pluggable interface for enterprise license validation.
+ *
+ * Enterprise clients integrate with their license servers by providing a custom adapter.
+ * The framework checks license status at key points (startup, feature gating, etc.)
+ *
+ * @example
+ * ```ts
+ * import { setLicenseAdapter } from "@spring-systems/core/adapters";
+ *
+ * setLicenseAdapter({
+ *     async validateLicense() {
+ *         const resp = await fetch("/api/license");
+ *         const data = await resp.json();
+ *         return { valid: data.active, expiresAt: new Date(data.expiresAt), tier: data.tier };
+ *     },
+ *     getLicenseInfo() {
+ *         return cachedLicenseInfo;
+ *     },
+ *     isFeatureLicensed(feature) {
+ *         return cachedLicenseInfo.features.includes(feature);
+ *     },
+ * });
+ * ```
+ *
+ * @module license-adapter
+ */
+/** Result of a license validation call */
+interface LicenseValidationResult {
+    /** Whether the license is currently valid */
+    valid: boolean;
+    /** When the license expires (undefined = perpetual) */
+    expiresAt?: Date;
+    /** License tier identifier (e.g. "community", "professional", "enterprise") */
+    tier?: string;
+    /** Human-readable message (e.g. "License expired", "Trial period") */
+    message?: string;
+}
+/** Cached license info (synchronous access) */
+interface LicenseInfo {
+    /** License tier (e.g. "standard", "professional", "enterprise") */
+    tier: string;
+    /** List of licensed feature keys */
+    features: string[];
+    /** When the license expires */
+    expiresAt?: Date;
+}
+interface LicenseAdapter {
+    /**
+     * Validate the license asynchronously (e.g. call a license server).
+     * Called at application startup and periodically.
+     */
+    validateLicense(): Promise<LicenseValidationResult>;
+    /**
+     * Get cached license info synchronously.
+     * Returns info from the last successful validation.
+     */
+    getLicenseInfo(): LicenseInfo;
+    /**
+     * Check if a specific feature is licensed.
+     * Uses cached license info for synchronous access.
+     */
+    isFeatureLicensed(feature: string): boolean;
+}
+declare function setLicenseAdapter(adapter: LicenseAdapter): void;
+declare function getLicenseAdapter(): LicenseAdapter;
+/**
+ * Reset the license adapter to the default noop (fail-closed) adapter.
+ * For testing only.
+ */
+declare function clearLicenseAdapter(): void;
+/**
+ * Convenience: validate the license via the configured adapter.
+ */
+declare function validateLicense(): Promise<LicenseValidationResult>;
+/**
+ * Convenience: check if a feature is licensed.
+ */
+declare function isFeatureLicensed(feature: string): boolean;
+/**
+ * Convenience: get cached license info.
+ */
+declare function getLicenseInfo(): LicenseInfo;
+
+/**
+ * Notification adapter — decouples API/validation layers from the UI notification system (react-toastify).
+ * Pattern matches setLogAdapter() in logger.ts.
+ * @module notification-adapter
+ */
+interface NotificationAdapter {
+    error(msg: string): void;
+    success(msg: string): void;
+    warning(msg: string): void;
+    info(msg: string): void;
+}
+declare function setNotificationAdapter(a: NotificationAdapter): void;
+declare function getNotificationAdapter(): NotificationAdapter;
+/** Reset to default notification adapter. For testing/integration teardown only. */
+declare function clearNotificationAdapter(): void;
+
+/**
+ * Telemetry adapter — provides hooks for observability, monitoring, and analytics.
+ *
+ * Enterprise deployments can integrate with APM tools (DataDog, New Relic, etc.)
+ * by setting a custom telemetry adapter. The framework emits telemetry events
+ * at key lifecycle points (form loads, API calls, errors, etc.)
+ *
+ * @example
+ * ```ts
+ * import { setTelemetryAdapter } from "@spring-systems/core/adapters";
+ *
+ * setTelemetryAdapter({
+ *     trackEvent(name, data) {
+ *         datadogRum.addAction(name, data);
+ *     },
+ *     trackError(error, context) {
+ *         Sentry.captureException(error, { extra: context });
+ *     },
+ *     trackTiming(metric, durationMs, data) {
+ *         performance.measure(metric, { duration: durationMs });
+ *     },
+ * });
+ * ```
+ *
+ * @module telemetry-adapter
+ */
+interface TelemetryAdapter {
+    /**
+     * Track a named event with optional structured data.
+     * Called on form save, list load, login, navigation, etc.
+     */
+    trackEvent(name: string, data?: Record<string, unknown>): void;
+    /**
+     * Track an error occurrence with optional context.
+     * Called on unhandled errors, API failures, middleware errors, etc.
+     */
+    trackError(error: Error | unknown, context?: Record<string, unknown>): void;
+    /**
+     * Track a timing measurement (e.g. API latency, form render time).
+     * @param metric - Metric name (e.g. "api.response_time", "form.load_time")
+     * @param durationMs - Duration in milliseconds
+     * @param data - Optional context data
+     */
+    trackTiming(metric: string, durationMs: number, data?: Record<string, unknown>): void;
+}
+declare function setTelemetryAdapter(adapter: TelemetryAdapter): void;
+declare function getTelemetryAdapter(): TelemetryAdapter;
+/** Reset telemetry adapter to no-op defaults. For testing/integration teardown only. */
+declare function clearTelemetryAdapter(): void;
+/**
+ * Convenience helper to track an event via the configured telemetry adapter.
+ * Safe to call even if no adapter is configured (no-op).
+ */
+declare function trackEvent(name: string, data?: Record<string, unknown>): void;
+/**
+ * Convenience helper to track an error via the configured telemetry adapter.
+ */
+declare function trackError(error: Error | unknown, context?: Record<string, unknown>): void;
+/**
+ * Convenience helper to track timing via the configured telemetry adapter.
+ */
+declare function trackTiming(metric: string, durationMs: number, data?: Record<string, unknown>): void;
+
+export { type ContentAdapter, type HttpAdapter, type HttpRequest, type LicenseAdapter, type LicenseInfo, type LicenseValidationResult, type NotificationAdapter, type TelemetryAdapter, clearContentAdapter, clearHttpAdapter, clearLicenseAdapter, clearNotificationAdapter, clearTelemetryAdapter, getContentRes, getHttpAdapter, getLicenseAdapter, getLicenseInfo, getNotificationAdapter, getTelemetryAdapter, isFeatureLicensed, setContentAdapter, setHttpAdapter, setLicenseAdapter, setNotificationAdapter, setTelemetryAdapter, trackError, trackEvent, trackTiming, validateLicense };

package/dist/adapters/index.js

@@ -0,0 +1,56 @@
+import {
+  clearHttpAdapter,
+  clearLicenseAdapter,
+  clearNotificationAdapter,
+  getHttpAdapter,
+  getLicenseAdapter,
+  getLicenseInfo,
+  getNotificationAdapter,
+  isFeatureLicensed,
+  setHttpAdapter,
+  setLicenseAdapter,
+  setNotificationAdapter,
+  validateLicense
+} from "../chunk-GON7Q32Q.js";
+import {
+  clearTelemetryAdapter,
+  getTelemetryAdapter,
+  setTelemetryAdapter,
+  trackError,
+  trackEvent,
+  trackTiming
+} from "../chunk-S6RPCN5H.js";
+import {
+  clearContentAdapter,
+  getContentRes,
+  setContentAdapter
+} from "../chunk-NQQIVCLX.js";
+import "../chunk-N2L4TUC4.js";
+import "../chunk-RUCXSQEY.js";
+import "../chunk-KX32MU3I.js";
+import "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+export {
+  clearContentAdapter,
+  clearHttpAdapter,
+  clearLicenseAdapter,
+  clearNotificationAdapter,
+  clearTelemetryAdapter,
+  getContentRes,
+  getHttpAdapter,
+  getLicenseAdapter,
+  getLicenseInfo,
+  getNotificationAdapter,
+  getTelemetryAdapter,
+  isFeatureLicensed,
+  setContentAdapter,
+  setHttpAdapter,
+  setLicenseAdapter,
+  setNotificationAdapter,
+  setTelemetryAdapter,
+  trackError,
+  trackEvent,
+  trackTiming,
+  validateLicense
+};
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

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

package/dist/auth/index.d.ts

@@ -0,0 +1,17 @@
+import { L as LogoutHandler, a as LogoutReason } from '../spring-instance-EbUh4mQb.js';
+import '../framework-config-types-DeUbx4bu.js';
+import '../middleware-types-DVG9C1qJ.js';
+import '../form-types-D3MdGpjA.js';
+import '../security-sanitize-Bb0PExM6.js';
+
+declare function setLogoutHandler(handler: LogoutHandler): void;
+declare function setAuthenticated(value: boolean): void;
+declare function isAuthenticated(): boolean;
+declare function triggerLogout(reason: LogoutReason): Promise<void>;
+/**
+ * Clears auth-related fallback and instance state.
+ * Intended for test/integration teardown.
+ */
+declare function clearAuthState(): void;
+
+export { LogoutHandler, LogoutReason, clearAuthState, isAuthenticated, setAuthenticated, setLogoutHandler, triggerLogout };

package/dist/auth/index.js

@@ -0,0 +1,19 @@
+import {
+  clearAuthState,
+  isAuthenticated,
+  setAuthenticated,
+  setLogoutHandler,
+  triggerLogout
+} from "../chunk-HFELOXDQ.js";
+import "../chunk-RUCXSQEY.js";
+import "../chunk-KX32MU3I.js";
+import "../chunk-EFUBAQCV.js";
+import "../chunk-PT4DIYUK.js";
+export {
+  clearAuthState,
+  isAuthenticated,
+  setAuthenticated,
+  setLogoutHandler,
+  triggerLogout
+};
+//# sourceMappingURL=index.js.map

package/dist/auth/index.js.map

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

package/dist/chunk-5D6XE7NJ.js

@@ -0,0 +1,16 @@
+// src/config/constants.ts
+var emptyGuid = "00000000-0000-0000-0000-000000000000";
+var DIALOG_CONTENT_SELECTOR = ".spring-dialog-content";
+var DND_TOUCH_CONSTRAINT = { delay: 200, tolerance: 5 };
+var STORAGE_KEYS = {
+  LANGUAGE: "language",
+  COLOR_THEME: "colorTheme"
+};
+
+export {
+  emptyGuid,
+  DIALOG_CONTENT_SELECTOR,
+  DND_TOUCH_CONSTRAINT,
+  STORAGE_KEYS
+};
+//# sourceMappingURL=chunk-5D6XE7NJ.js.map

package/dist/chunk-5D6XE7NJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config/constants.ts"],"sourcesContent":["/** Empty GUID for new records */\nexport const emptyGuid = \"00000000-0000-0000-0000-000000000000\";\n\n/** Generic interface for select options */\nexport interface CodeList {\n    id_public: string;\n    name: string;\n    code?: string;\n    version?: number;\n}\n\n/** Interface for persons (full_name) */\nexport interface CodeListFullName {\n    id_public: string;\n    full_name: string;\n    first_name: string;\n    last_name?: string;\n}\n\nexport interface CodeListNumber {\n    id_public: number;\n    name: string;\n}\n\nexport type Operator = \"=\" | \">\" | \">=\" | \"<\" | \"<=\" | \"!=\" | \"in\" | \"between\";\n\n/** CSS selector for an open dialog (detection in shortcut hooks) */\nexport const DIALOG_CONTENT_SELECTOR = \".spring-dialog-content\";\n\n/** DnD TouchSensor activation constraint (delay + tolerance) */\nexport const DND_TOUCH_CONSTRAINT = { delay: 200, tolerance: 5 } as const;\n\nexport const STORAGE_KEYS = {\n    LANGUAGE: \"language\",\n    COLOR_THEME: \"colorTheme\",\n} as const;\n\n/** Union type of all storage key values. */\nexport type StorageKey = (typeof STORAGE_KEYS)[keyof typeof STORAGE_KEYS];\n"],"mappings":";AACO,IAAM,YAAY;AA0BlB,IAAM,0BAA0B;AAGhC,IAAM,uBAAuB,EAAE,OAAO,KAAK,WAAW,EAAE;AAExD,IAAM,eAAe;AAAA,EACxB,UAAU;AAAA,EACV,aAAa;AACjB;","names":[]}

package/dist/chunk-EFUBAQCV.js

@@ -0,0 +1,94 @@
+import {
+  SpringConfigError
+} from "./chunk-PT4DIYUK.js";
+
+// src/utils/dev-warnings.ts
+function isDevelopmentRuntime() {
+  const processNodeEnv = typeof process !== "undefined" ? process.env?.NODE_ENV : void 0;
+  if (typeof processNodeEnv === "string") {
+    return processNodeEnv !== "production";
+  }
+  const importMetaEnv = import.meta.env;
+  if (!importMetaEnv) {
+    return false;
+  }
+  if (importMetaEnv.DEV === true) return true;
+  if (importMetaEnv.PROD === true) return false;
+  if (typeof importMetaEnv.MODE === "string") return importMetaEnv.MODE !== "production";
+  if (typeof importMetaEnv.NODE_ENV === "string") return importMetaEnv.NODE_ENV !== "production";
+  return false;
+}
+var __DEV__ = isDevelopmentRuntime();
+function devWarn(context, message) {
+  if (__DEV__) {
+    console.warn(`[${context}] ${message}`);
+  }
+}
+function devThrow(context, message) {
+  const full = `[${context}] ${message}`;
+  if (__DEV__) {
+    throw new Error(full);
+  }
+  console.warn(full);
+}
+function devAssert(condition, context, message) {
+  if (__DEV__ && !condition) {
+    throw new Error(`[${context}] ${message}`);
+  }
+}
+
+// src/instance/current-instance.ts
+var currentInstance = null;
+function getAliveCurrentInstance() {
+  if (!currentInstance) return null;
+  if (currentInstance.state === "disposed") {
+    currentInstance = null;
+    return null;
+  }
+  return currentInstance;
+}
+function setSpringInstance(instance) {
+  const activeCurrent = getAliveCurrentInstance();
+  if (activeCurrent && activeCurrent !== instance) {
+    if (typeof window !== "undefined") {
+      devWarn(
+        "SpringInstance",
+        "Replacing an active SpringInstance. If you have multiple SpringProviders, ensure the previous one is unmounted before mounting a new one. For SSR, use React Context instead of the global singleton."
+      );
+    }
+  }
+  currentInstance = instance;
+}
+function getSpringInstance() {
+  const instance = getAliveCurrentInstance();
+  if (!instance) {
+    throw new SpringConfigError(
+      "SpringInstance not initialized. Ensure <SpringProvider> is mounted or call setSpringInstance() before accessing the instance."
+    );
+  }
+  return instance;
+}
+function tryGetSpringInstance() {
+  return getAliveCurrentInstance();
+}
+function clearSpringInstance() {
+  currentInstance = null;
+}
+function clearSpringInstanceIfCurrent(instance) {
+  if (currentInstance === instance) {
+    currentInstance = null;
+  }
+}
+
+export {
+  __DEV__,
+  devWarn,
+  devThrow,
+  devAssert,
+  setSpringInstance,
+  getSpringInstance,
+  tryGetSpringInstance,
+  clearSpringInstance,
+  clearSpringInstanceIfCurrent
+};
+//# sourceMappingURL=chunk-EFUBAQCV.js.map

package/dist/chunk-EFUBAQCV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/dev-warnings.ts","../src/instance/current-instance.ts"],"sourcesContent":["/**\n * Dev-mode validation helpers.\n * In development: throws errors / logs warnings for invalid usage.\n * In production: silent (no runtime cost beyond a single boolean check).\n * @module dev-warnings\n */\n\nfunction isDevelopmentRuntime(): boolean {\n    const processNodeEnv = typeof process !== \"undefined\" ? process.env?.NODE_ENV : undefined;\n    if (typeof processNodeEnv === \"string\") {\n        return processNodeEnv !== \"production\";\n    }\n\n    const importMetaEnv = (import.meta as ImportMeta & { env?: Record<string, unknown> }).env;\n    if (!importMetaEnv) {\n        return false;\n    }\n\n    if (importMetaEnv.DEV === true) return true;\n    if (importMetaEnv.PROD === true) return false;\n    if (typeof importMetaEnv.MODE === \"string\") return importMetaEnv.MODE !== \"production\";\n    if (typeof importMetaEnv.NODE_ENV === \"string\") return importMetaEnv.NODE_ENV !== \"production\";\n\n    return false;\n}\n\nconst __DEV__ = isDevelopmentRuntime();\n\n/**\n * Log a warning in development mode only.\n * No-op in production.\n */\nexport function devWarn(context: string, message: string): void {\n    if (__DEV__) {\n        console.warn(`[${context}] ${message}`);\n    }\n}\n\n/**\n * Throw an error in development mode, log a warning in production.\n * Use for invalid API usage that should be caught during development.\n */\nexport function devThrow(context: string, message: string): void {\n    const full = `[${context}] ${message}`;\n    if (__DEV__) {\n        throw new Error(full);\n    }\n    console.warn(full);\n}\n\n/**\n * Assert a condition in development mode.\n * Throws if condition is false in dev, no-op in production.\n */\nexport function devAssert(condition: boolean, context: string, message: string): void {\n    if (__DEV__ && !condition) {\n        throw new Error(`[${context}] ${message}`);\n    }\n}\n\nexport { __DEV__ };\n","/**\n * Current instance bridge — the one remaining singleton.\n * Imperative code (API calls, middleware, etc.) reads from getSpringInstance().\n * The SpringProvider in ui sets this via setSpringInstance().\n *\n * **SSR safety note:** This module uses a module-level variable, which means\n * concurrent SSR requests in the same Node.js process will share the same\n * instance. For multi-tenant SSR, use React Context instead of getSpringInstance().\n *\n * @module current-instance\n */\n\nimport { SpringConfigError } from \"../errors/errors\";\nimport { devWarn } from \"../utils/dev-warnings\";\nimport type { SpringInstance } from \"./spring-instance\";\n\nlet currentInstance: SpringInstance | null = null;\n\nfunction getAliveCurrentInstance(): SpringInstance | null {\n    if (!currentInstance) return null;\n    if (currentInstance.state === \"disposed\") {\n        currentInstance = null;\n        return null;\n    }\n    return currentInstance;\n}\n\n/**\n * Set the current SpringInstance. Called once by SpringProvider on mount.\n * Warns if replacing an active (non-disposed) instance — this indicates\n * either multiple SpringProviders or missing cleanup.\n */\nexport function setSpringInstance(instance: SpringInstance): void {\n    const activeCurrent = getAliveCurrentInstance();\n    if (activeCurrent && activeCurrent !== instance) {\n        // During SSR (no `window`), the module singleton persists between requests\n        // because useEffect cleanup doesn't run server-side. Only warn on the client\n        // where multiple simultaneous SpringProviders indicate a real problem.\n        if (typeof window !== \"undefined\") {\n            devWarn(\n                \"SpringInstance\",\n                \"Replacing an active SpringInstance. If you have multiple SpringProviders, \" +\n                    \"ensure the previous one is unmounted before mounting a new one. \" +\n                    \"For SSR, use React Context instead of the global singleton.\",\n            );\n        }\n    }\n    currentInstance = instance;\n}\n\n/**\n * Get the current SpringInstance. Throws if not set.\n * Use this in imperative code that requires a live instance.\n */\nexport function getSpringInstance(): SpringInstance {\n    const instance = getAliveCurrentInstance();\n    if (!instance) {\n        throw new SpringConfigError(\n            \"SpringInstance not initialized. Ensure <SpringProvider> is mounted or call setSpringInstance() before accessing the instance.\",\n        );\n    }\n    return instance;\n}\n\n/**\n * Get the current SpringInstance or null if not yet initialized.\n * Use this in code that may run before SpringProvider mounts (e.g. config setup).\n */\nexport function tryGetSpringInstance(): SpringInstance | null {\n    return getAliveCurrentInstance();\n}\n\n/**\n * Clear the current instance. For testing and cleanup only.\n */\nexport function clearSpringInstance(): void {\n    currentInstance = null;\n}\n\n/**\n * Clear the current instance only if it matches the provided reference.\n * Prevents disposing an old instance from clearing a newer mounted instance.\n */\nexport function clearSpringInstanceIfCurrent(instance: SpringInstance): void {\n    if (currentInstance === instance) {\n        currentInstance = null;\n    }\n}\n"],"mappings":";;;;;AAOA,SAAS,uBAAgC;AACrC,QAAM,iBAAiB,OAAO,YAAY,cAAc,QAAQ,KAAK,WAAW;AAChF,MAAI,OAAO,mBAAmB,UAAU;AACpC,WAAO,mBAAmB;AAAA,EAC9B;AAEA,QAAM,gBAAiB,YAA+D;AACtF,MAAI,CAAC,eAAe;AAChB,WAAO;AAAA,EACX;AAEA,MAAI,cAAc,QAAQ,KAAM,QAAO;AACvC,MAAI,cAAc,SAAS,KAAM,QAAO;AACxC,MAAI,OAAO,cAAc,SAAS,SAAU,QAAO,cAAc,SAAS;AAC1E,MAAI,OAAO,cAAc,aAAa,SAAU,QAAO,cAAc,aAAa;AAElF,SAAO;AACX;AAEA,IAAM,UAAU,qBAAqB;AAM9B,SAAS,QAAQ,SAAiB,SAAuB;AAC5D,MAAI,SAAS;AACT,YAAQ,KAAK,IAAI,OAAO,KAAK,OAAO,EAAE;AAAA,EAC1C;AACJ;AAMO,SAAS,SAAS,SAAiB,SAAuB;AAC7D,QAAM,OAAO,IAAI,OAAO,KAAK,OAAO;AACpC,MAAI,SAAS;AACT,UAAM,IAAI,MAAM,IAAI;AAAA,EACxB;AACA,UAAQ,KAAK,IAAI;AACrB;AAMO,SAAS,UAAU,WAAoB,SAAiB,SAAuB;AAClF,MAAI,WAAW,CAAC,WAAW;AACvB,UAAM,IAAI,MAAM,IAAI,OAAO,KAAK,OAAO,EAAE;AAAA,EAC7C;AACJ;;;AC1CA,IAAI,kBAAyC;AAE7C,SAAS,0BAAiD;AACtD,MAAI,CAAC,gBAAiB,QAAO;AAC7B,MAAI,gBAAgB,UAAU,YAAY;AACtC,sBAAkB;AAClB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAOO,SAAS,kBAAkB,UAAgC;AAC9D,QAAM,gBAAgB,wBAAwB;AAC9C,MAAI,iBAAiB,kBAAkB,UAAU;AAI7C,QAAI,OAAO,WAAW,aAAa;AAC/B;AAAA,QACI;AAAA,QACA;AAAA,MAGJ;AAAA,IACJ;AAAA,EACJ;AACA,oBAAkB;AACtB;AAMO,SAAS,oBAAoC;AAChD,QAAM,WAAW,wBAAwB;AACzC,MAAI,CAAC,UAAU;AACX,UAAM,IAAI;AAAA,MACN;AAAA,IACJ;AAAA,EACJ;AACA,SAAO;AACX;AAMO,SAAS,uBAA8C;AAC1D,SAAO,wBAAwB;AACnC;AAKO,SAAS,sBAA4B;AACxC,oBAAkB;AACtB;AAMO,SAAS,6BAA6B,UAAgC;AACzE,MAAI,oBAAoB,UAAU;AAC9B,sBAAkB;AAAA,EACtB;AACJ;","names":[]}