@absolutejs/absolute 0.19.0-beta.999 → 0.20.0-beta.1

package/dist/angular/components/constants.js

@@ -4,6 +4,12 @@ export const ANSI_ESCAPE_LENGTH = 3;
 export const ASCII_SPACE = 32;
 export const BASE_36_RADIX = 36;
 export const BUN_BUILD_WARNING_SUPPRESSION = 'wildcard sideEffects are not supported yet';
+/* Tailwind v4 at-rules that Bun's native CSS parser doesn't recognize.
+   When a user imports their Tailwind entry CSS from a TS/TSX file, Bun's
+   bundler walks it and warns about each unknown at-rule even though the
+   actual Tailwind output is produced via the separate tailwindcss compile()
+   pipeline (see compileTailwind.ts). The warnings are noise — suppress them. */
+export const TAILWIND_BUN_CSS_WARNING_PATTERN = /invalid @ rule encountered: '@(theme|tailwind|source|utility|variant|custom-variant|apply|reference|plugin|config)'/;
 export const BODY_SLICE_LENGTH = 2000;
 export const BYTES_PER_KILOBYTE = 1024;
 export const CLI_ARGS_OFFSET = 3;
@@ -20,6 +26,10 @@ export const FILE_PROTOCOL_PREFIX_LENGTH = 7;
 export const FOCUS_ID_PREFIX_LENGTH = 3;
 export const FOCUS_IDX_PREFIX_LENGTH = 4;
 export const FOCUS_NAME_PREFIX_LENGTH = 5;
+export const ESLINT_STUDIO_DEFAULT_HOST = 'eslint.absolute.localhost';
+export const ESLINT_STUDIO_DEFAULT_PORT = 4099;
+export const CONFIG_DEFAULT_HOST = 'config.absolute.localhost';
+export const CONFIG_DEFAULT_PORT = 4099;
 export const HMR_UPDATE_TIMEOUT_MS = 2000;
 export const HOOK_SIGNATURE_LENGTH = 12;
 export const EXCLUDE_LAST_OFFSET = -1;
@@ -34,6 +44,7 @@ export const IMAGE_DEFAULT_DEVICE_SIZES = [
 export const IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
 export const IMAGE_DEFAULT_QUALITY = 75;
 export const IMAGE_GLOB_SUFFIX_LENGTH = 2;
+export const INSTANCE_PROBE_TIMEOUT_MS = 250;
 export const MAX_ERROR_LENGTH = 200;
 export const MAX_RECONNECT_ATTEMPTS = 60;
 export const MILLISECONDS_IN_A_SECOND = 1000;
@@ -46,6 +57,18 @@ export const MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND *
     HOURS_IN_DAY;
 export const OVERLAY_FADE_DURATION_MS = 150;
 export const PING_INTERVAL_MS = 30_000;
+export const LIST_LOG_TAIL_MAX_BYTES = 65_536;
+export const LIST_TUI_COLUMN_GAP = 2;
+export const LIST_TUI_DEFAULT_HEIGHT = 28;
+export const LIST_TUI_DEFAULT_WIDTH = 100;
+export const LIST_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30;
+export const LIST_TUI_FOOTER_LINE_COUNT = 2;
+export const LIST_TUI_MARKER_WIDTH = 2;
+export const LIST_TUI_MIN_LOG_HEIGHT = 3;
+export const LIST_TUI_MIN_URL_WIDTH = 16;
+export const LIST_TUI_RENDER_DEBOUNCE_MS = 16;
+export const LIST_TUI_STATUS_MESSAGE_TIMEOUT_MS = 4000;
+export const LIST_WATCH_REFRESH_MS = 1000;
 export const RAF_BATCH_COUNT = 3;
 export const RANDOM_ID_END_INDEX = 11;
 export const REBUILD_BATCH_DELAY_MS = 10;
@@ -61,6 +84,26 @@ export const TIME_PRECISION = 2;
 export const TWO_THIRDS = 2 / 3;
 export const UNFOUND_INDEX = -1;
 export const WEBSOCKET_NORMAL_CLOSURE = 1000;
+// Default Bun WebSocket idleTimeout (seconds) applied to every absolute server.
+// Long-lived sockets (voice intake, referee, realtime sync) sit idle during
+// greeting playback or while a user listens silently — no client→server frames.
+// Without an explicit value the WS idleTimeout falls back to Elysia's small
+// top-level serve default (~30s, closing at ~60s), which kills these sessions
+// mid-call with INACTIVE_CLIENT. 240s outlasts any greeting or think-pause and
+// gives a briefly-suspended tab time to wake and reconnect. Paired with Bun's
+// `sendPings` (protocol-level keepalive the browser answers without JS, so a
+// throttled background tab still responds). Bun's hard ceiling is 960s.
+export const DEFAULT_WEBSOCKET_IDLE_TIMEOUT_SECONDS = 240;
+// HTTP idleTimeout for Bun.serve. Bun's DEFAULT is a hostile 10s for a
+// framework meant to host streaming/AI workloads: a long-lived SSE response
+// (or any long poll) that stays silent past 10s — e.g. an agentic AI turn
+// waiting on the model's first token after a large tool result inflates the
+// prompt — gets its socket reaped with no error, and the client hangs. 240s
+// mirrors the WS default and outlasts realistic model think-pauses; Bun's
+// hard ceiling for HTTP idleTimeout is 255s. Override per-app with the
+// ABSOLUTE_IDLE_TIMEOUT env var (seconds; 0 disables the timeout entirely).
+export const DEFAULT_HTTP_IDLE_TIMEOUT_SECONDS = 240;
+export const MAX_HTTP_IDLE_TIMEOUT_SECONDS = 255;
 export const WORKSPACE_COMMAND_ARGS_OFFSET = 3;
 export const WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30;
 export const WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60;

package/dist/angular/components/core/streamingSlotRegistrar.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-cCwuNc/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-G3V2Ai/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");

package/dist/angular/components/core/streamingSlotRegistry.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-cCwuNc/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-G3V2Ai/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
@@ -48,7 +48,7 @@ var warnMissingStreamingSlotCollector = (primitiveName) => {
   getWarningController()?.maybeWarn(primitiveName);
 };
 
-// .angular-partial-tmp-cCwuNc/src/core/streamingSlotRegistry.ts
+// .angular-partial-tmp-G3V2Ai/src/core/streamingSlotRegistry.ts
 var STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
 var isObjectRecord2 = (value) => Boolean(value) && typeof value === "object";
 var isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";

package/dist/angular/hmrPreserveCore.ts

@@ -16,136 +16,24 @@ export type InstanceKeyMap = WeakMap<object, string>;
 export type RebootFlag = { value: boolean };
 export type RebootStats = { captured: number; restoredKeys: Set<string> };
 
-type PreserveScope = typeof globalThis & {
-	__ABS_HMR_INSTANCE_STATE__?: StateCache;
-	__ABS_HMR_TRACKED_INSTANCES__?: InstanceTracker;
-	__ABS_HMR_INSTANCE_KEYS__?: InstanceKeyMap;
-	__ABS_HMR_REBOOT_IN_PROGRESS__?: RebootFlag;
-	__ABS_HMR_REBOOT_STATS__?: RebootStats;
-};
-
-export const isHmrPreserveDev = (): boolean => {
-	// SSR safety: globalThis on the server is process-wide and shared
-	// across requests, so writing to the preservation cache during SSR
-	// would leak request state between users. Gate strictly on the
-	// presence of a browser `window` *and* a dev signal — neither is
-	// true in a production build, so this is a hard no-op there too.
-	if (typeof window === 'undefined') return false;
-	const scope = globalThis as { __DEV__?: unknown; ngDevMode?: unknown };
-
-	return Boolean(scope.__DEV__) || Boolean(scope.ngDevMode);
-};
-
-export const getCache = (): StateCache => {
-	const scope = globalThis as PreserveScope;
-
-	return (scope.__ABS_HMR_INSTANCE_STATE__ ??= new Map());
-};
-
-export const getTracker = (): InstanceTracker => {
-	const scope = globalThis as PreserveScope;
-
-	return (scope.__ABS_HMR_TRACKED_INSTANCES__ ??= new Set());
-};
-
-export const getKeyMap = (): InstanceKeyMap => {
-	const scope = globalThis as PreserveScope;
-
-	return (scope.__ABS_HMR_INSTANCE_KEYS__ ??= new WeakMap());
-};
-
-export const getRebootFlag = (): RebootFlag => {
-	const scope = globalThis as PreserveScope;
-
-	return (scope.__ABS_HMR_REBOOT_IN_PROGRESS__ ??= { value: false });
-};
-
-export const getRebootStats = (): RebootStats => {
-	const scope = globalThis as PreserveScope;
-
-	return (scope.__ABS_HMR_REBOOT_STATS__ ??= {
-		captured: 0,
-		restoredKeys: new Set()
-	});
-};
-
-/* Filter for values that are safe to preserve across an HMR full
-   re-bootstrap. Snapshots the OLD app's instance state into a cache
-   and copies it back onto the NEW instance — but holding references
-   to the OLD app's Angular-injected services (HttpClient,
-   ApplicationRef, subscriptions tied to the destroyed injector, etc.)
-   and restoring them onto the new instance would corrupt the new app:
-   the new `HttpClient` from the new injector would be replaced by a
-   stale ref pointing at a destroyed graph. So: primitives, plain `{}`
-   objects, and arrays of those — covers the common cases (auth tokens,
-   cached query results, search queries, pagination state) without
-   leaking Angular-injected dependencies, RxJS subjects, DOM nodes, or
-   other live references. */
-export const isPreservable = (value: unknown, depth = 0): boolean => {
-	if (depth > 8) return false;
-	if (value === null || value === undefined) return true;
-	const t = typeof value;
-	if (t === 'string' || t === 'number' || t === 'boolean' || t === 'bigint')
-		return true;
-	if (t === 'function' || t === 'symbol') return false;
-	if (Array.isArray(value)) {
-		return value.every((item) => isPreservable(item, depth + 1));
-	}
-	if (t === 'object') {
-		const proto = Object.getPrototypeOf(value);
-		// Only POJOs — class instances (HttpClient, BehaviorSubject, Date,
-		// Map, etc.) carry runtime identity that the new instance must
-		// get from its own injector / construction.
-		if (proto !== Object.prototype && proto !== null) return false;
-
-		return Object.values(value as object).every((v) =>
-			isPreservable(v, depth + 1)
-		);
-	}
-
-	return false;
-};
-
-export const buildCacheKey = (
-	instance: object,
-	key?: unknown
-): string | null => {
+const isRebootFlag = (value: unknown): value is RebootFlag =>
+	typeof value === 'object' &&
+	value !== null &&
+	typeof Reflect.get(value, 'value') === 'boolean';
+const isRebootStats = (value: unknown): value is RebootStats =>
+	typeof value === 'object' &&
+	value !== null &&
+	typeof Reflect.get(value, 'captured') === 'number' &&
+	Reflect.get(value, 'restoredKeys') instanceof Set;
+
+export const buildCacheKey = (instance: object, key?: unknown) => {
 	const className = instance.constructor?.name;
 	if (!className || className === 'Object') return null;
 	const suffix = key === undefined || key === null ? '' : String(key);
 
 	return `${className}:${suffix}`;
 };
-
-/** Copy preservable own properties from the cached snapshot onto the
- *  instance. Records the restoration in stats so the end-of-reboot
- *  summary can list which classes had state restored. Returns whether
- *  anything was actually written. */
-export const restoreFromCacheCore = (
-	instance: object,
-	key: string
-): boolean => {
-	const cache = getCache();
-	const stored = cache.get(key);
-	if (!stored) return false;
-
-	for (const [prop, value] of Object.entries(stored)) {
-		try {
-			(instance as Record<string, unknown>)[prop] = value;
-		} catch {
-			/* property is non-writable / has a setter that threw — skip */
-		}
-	}
-
-	getRebootStats().restoredKeys.add(key);
-
-	return true;
-};
-
-/** Snapshot every tracked instance's preservable own properties into
- *  the shared cache and flip the reboot-in-progress flag on. Called by
- *  the dev-client HMR handler right before `destroyAngularApp()`. */
-export const captureTrackedInstanceStates = (): void => {
+export const captureTrackedInstanceStates = () => {
 	if (!isHmrPreserveDev()) return;
 
 	const cache = getCache();
@@ -180,7 +68,7 @@ export const captureTrackedInstanceStates = (): void => {
 
 		const props: Record<string, unknown> = {};
 		for (const prop of Object.keys(instance)) {
-			const value = (instance as Record<string, unknown>)[prop];
+			const value = Reflect.get(instance, prop);
 			if (isPreservable(value)) props[prop] = value;
 		}
 		cache.set(fullKey, props);
@@ -198,21 +86,14 @@ export const captureTrackedInstanceStates = (): void => {
 
 	getRebootFlag().value = true;
 };
-
-/** Clear the active-reboot flag and emit a one-line summary so
- *  developers can see at-a-glance which classes had state preserved.
- *  Called by the dev-client HMR handler after the new app has reported
- *  stable. After this, `preserveAcrossHmr` calls track but don't
- *  restore — so navigating to a route after HMR doesn't resurrect
- *  stale state from the last reboot. */
-export const endHmrReboot = (): void => {
+export const endHmrReboot = () => {
 	if (!isHmrPreserveDev()) return;
 	getRebootFlag().value = false;
 
 	const stats = getRebootStats();
 	if (stats.captured > 0) {
 		const restored = Array.from(stats.restoredKeys)
-			.map((k) => k.replace(/:$/, ''))
+			.map((cacheKey) => cacheKey.replace(/:$/, ''))
 			.sort();
 		console.info(
 			`[HMR] Full re-bootstrap: restored state for ${restored.length}/${stats.captured} tracked instance(s)${
@@ -221,3 +102,120 @@ export const endHmrReboot = (): void => {
 		);
 	}
 };
+export const getCache = () => {
+	const current: unknown = Reflect.get(
+		globalThis,
+		'__ABS_HMR_INSTANCE_STATE__'
+	);
+	if (current instanceof Map) return current;
+	const cache: StateCache = new Map();
+	Reflect.set(globalThis, '__ABS_HMR_INSTANCE_STATE__', cache);
+
+	return cache;
+};
+export const getKeyMap = () => {
+	const current: unknown = Reflect.get(
+		globalThis,
+		'__ABS_HMR_INSTANCE_KEYS__'
+	);
+	if (current instanceof WeakMap) return current;
+	const keyMap: InstanceKeyMap = new WeakMap();
+	Reflect.set(globalThis, '__ABS_HMR_INSTANCE_KEYS__', keyMap);
+
+	return keyMap;
+};
+export const getRebootFlag = () => {
+	const current: unknown = Reflect.get(
+		globalThis,
+		'__ABS_HMR_REBOOT_IN_PROGRESS__'
+	);
+	if (isRebootFlag(current)) return current;
+	const flag: RebootFlag = { value: false };
+	Reflect.set(globalThis, '__ABS_HMR_REBOOT_IN_PROGRESS__', flag);
+
+	return flag;
+};
+export const getRebootStats = () => {
+	const current: unknown = Reflect.get(
+		globalThis,
+		'__ABS_HMR_REBOOT_STATS__'
+	);
+	if (isRebootStats(current)) return current;
+	const stats: RebootStats = {
+		captured: 0,
+		restoredKeys: new Set()
+	};
+	Reflect.set(globalThis, '__ABS_HMR_REBOOT_STATS__', stats);
+
+	return stats;
+};
+export const getTracker = () => {
+	const current: unknown = Reflect.get(
+		globalThis,
+		'__ABS_HMR_TRACKED_INSTANCES__'
+	);
+	if (current instanceof Set) return current;
+	const tracker: InstanceTracker = new Set();
+	Reflect.set(globalThis, '__ABS_HMR_TRACKED_INSTANCES__', tracker);
+
+	return tracker;
+};
+export const isHmrPreserveDev = () => {
+	// SSR safety: globalThis on the server is process-wide and shared
+	// across requests, so writing to the preservation cache during SSR
+	// would leak request state between users. Gate strictly on the
+	// presence of a browser `window` *and* a dev signal — neither is
+	// true in a production build, so this is a hard no-op there too.
+	if (typeof window === 'undefined') return false;
+
+	return (
+		Boolean(Reflect.get(globalThis, '__DEV__')) ||
+		Boolean(Reflect.get(globalThis, 'ngDevMode'))
+	);
+};
+export const isPreservable = (value: unknown, depth = 0): boolean => {
+	if (depth > 8) return false;
+	if (value === null || value === undefined) return true;
+	const valueType = typeof value;
+	if (
+		valueType === 'string' ||
+		valueType === 'number' ||
+		valueType === 'boolean' ||
+		valueType === 'bigint'
+	)
+		return true;
+	if (valueType === 'function' || valueType === 'symbol') return false;
+	if (Array.isArray(value)) {
+		return value.every((item) => isPreservable(item, depth + 1));
+	}
+	if (valueType === 'object') {
+		const proto = Object.getPrototypeOf(value);
+		// Only POJOs — class instances (HttpClient, BehaviorSubject, Date,
+		// Map, etc.) carry runtime identity that the new instance must
+		// get from its own injector / construction.
+		if (proto !== Object.prototype && proto !== null) return false;
+
+		return Object.values(value).every((nestedValue) =>
+			isPreservable(nestedValue, depth + 1)
+		);
+	}
+
+	return false;
+};
+export const restoreFromCacheCore = (instance: object, key: string) => {
+	const cache = getCache();
+	const stored = cache.get(key);
+	if (!stored) return false;
+
+	for (const [prop, value] of Object.entries(stored)) {
+		try {
+			Reflect.set(instance, prop, value);
+		} catch {
+			/* property is non-writable / has a setter that threw — skip */
+		}
+	}
+
+	getRebootStats().restoredKeys.add(key);
+
+	return true;
+};