@absolutejs/voice 0.0.1

package/README.md

@@ -0,0 +1,150 @@
+# `@absolutejs/voice`
+
+`@absolutejs/voice` is the voice session layer for AbsoluteJS. It owns the duplex WebSocket lifecycle, transcript buffering, turn commits, reconnect behavior, and client primitives, while keeping speech vendors and session storage pluggable.
+
+## Install
+
+```bash
+bun add @absolutejs/voice
+```
+
+Peer dependencies:
+
+- `@absolutejs/absolute`
+- `elysia`
+
+Optional framework entrypoints:
+
+- `@absolutejs/voice/react`
+- `@absolutejs/voice/vue`
+- `@absolutejs/voice/svelte`
+- `@absolutejs/voice/angular`
+- `@absolutejs/voice/client`
+
+## Route Setup
+
+```ts
+import { Elysia } from 'elysia';
+import { voice, createVoiceMemoryStore } from '@absolutejs/voice';
+import { deepgram } from '@absolutejs/voice-deepgram';
+
+const app = new Elysia()
+	.use(
+		voice({
+			path: '/voice',
+			onComplete: async ({ session }) => {
+				console.log(session.turns);
+			},
+			async onTurn({ turn }) {
+				return {
+					assistantText: `You said: ${turn.text}`
+				};
+			},
+			session: createVoiceMemoryStore(),
+			stt: deepgram({
+				apiKey: process.env.DEEPGRAM_API_KEY!,
+				model: 'nova-3'
+			})
+		})
+	);
+```
+
+`createVoiceMemoryStore()` is dev-only. Real deployments should provide a shared store backed by Redis, Postgres, or equivalent.
+
+## Adapter Contract
+
+Adapters normalize vendor behavior into a core event model so the plugin never branches on vendor names.
+
+### STT adapter
+
+```ts
+type STTAdapter = {
+	kind: 'stt';
+	open: (
+		options: STTAdapterOpenOptions
+	) => Promise<STTAdapterSession> | STTAdapterSession;
+};
+
+type STTAdapterSession = {
+	on: <K extends keyof STTSessionEventMap>(
+		event: K,
+		handler: (payload: STTSessionEventMap[K]) => void | Promise<void>
+	) => () => void;
+	send: (audio: AudioChunk) => Promise<void>;
+	close: (reason?: string) => Promise<void>;
+};
+```
+
+Normalized events:
+
+- `partial`: interim transcript updates
+- `final`: finalized transcript segments
+- `endOfTurn`: vendor-native turn completion when available
+- `error`: recoverable or fatal adapter failures
+- `close`: adapter transport shutdown
+
+Requirements for third-party adapters:
+
+- accept `16kHz` mono `pcm_s16le` from core without mutating the contract
+- map vendor transcript payloads into `Transcript`
+- emit `endOfTurn` only when the vendor actually provides a native signal
+- never leak vendor-specific types through the core surface
+
+## Session Storage Contract
+
+Voice uses the same bring-your-own-session pattern as AI, now via the shared generic `SessionStore` contract.
+
+```ts
+type SessionStore<TSession, TSummary> = {
+	get: (id: string) => Promise<TSession | undefined>;
+	getOrCreate: (id: string) => Promise<TSession>;
+	set: (id: string, value: TSession) => Promise<void>;
+	list: () => Promise<TSummary[]>;
+	remove: (id: string) => Promise<void>;
+};
+```
+
+Voice specializes it as:
+
+```ts
+type VoiceSessionStore = SessionStore<
+	VoiceSessionRecord,
+	VoiceSessionSummary
+>;
+```
+
+A storage implementation must:
+
+- persist the whole `VoiceSessionRecord`
+- make `getOrCreate()` safe across multiple app instances
+- keep `set()` atomic enough that reconnects do not re-fire committed turns
+- return `list()` summaries without loading full transcripts when possible
+
+For Redis or Postgres stores, the usual pattern is:
+
+1. `get(sessionId)` before opening a socket
+2. `getOrCreate(sessionId)` on first contact
+3. mutate the record in memory for a single turn transition
+4. `set(sessionId, updatedRecord)` immediately after each state change
+
+## Reconnect Behavior
+
+Default reconnect strategy is `resume-last-turn`.
+
+- `resume-last-turn`: reload the persisted transcript buffer and continue from the last uncommitted turn
+- `restart`: discard the persisted voice turn state and start fresh on reconnect exhaustion
+- `fail`: mark the session failed when reconnect policy is exhausted
+
+If an adapter does not emit native end-of-turn events, core falls back to silence detection with a default `700ms` threshold.
+
+## Client Primitives
+
+Browser and framework helpers sit on top of the same connection core:
+
+- `createVoiceStream()` in `@absolutejs/voice/client`
+- `useVoiceStream()` in `@absolutejs/voice/react`
+- `useVoiceStream()` in `@absolutejs/voice/vue`
+- `createVoiceStream()` in `@absolutejs/voice/svelte`
+- `VoiceStreamService` in `@absolutejs/voice/angular`
+
+For plain HTML or HTMX flows, use `@absolutejs/voice/client` directly.

package/dist/absolutejs/src/angular/angularDeps.d.ts

@@ -0,0 +1,2 @@
+import type { AngularDeps } from '../../types/angular';
+export declare const getAngularDeps: () => Promise<AngularDeps>;

package/dist/absolutejs/src/angular/angularPatch.d.ts

@@ -0,0 +1 @@
+export declare const applyPatches: () => Promise<boolean>;

package/dist/absolutejs/src/angular/injectorPatch.d.ts

@@ -0,0 +1 @@
+export declare const patchAngularInjectorSingleton: () => void;

package/dist/absolutejs/src/angular/islands.d.ts

@@ -0,0 +1,3 @@
+export declare const getAngularIslandSelector: (_islandId: string) => string;
+export declare const mountAngularIsland: <Props extends Record<string, unknown>>(component: import("@angular/core").Type<object>, element: HTMLElement, props: Props, islandId: string) => Promise<import("@angular/core").ApplicationRef>;
+export declare const renderAngularIslandToHtml: <Props extends Record<string, unknown>>(component: import("@angular/core").Type<object>, props: Props, islandId: string) => Promise<string>;

package/dist/absolutejs/src/angular/lowerDeferSyntax.d.ts

@@ -0,0 +1,18 @@
+export type LoweredAngularDeferSlot = {
+    delayMs: number;
+    errorHtml: string | null;
+    fallbackHtml: string;
+    id: string;
+    resolvedBindings: Array<{
+        expression: string;
+        key: string;
+    }>;
+    resolvedHtml: string;
+    resolvedTemplate: string;
+};
+export type LoweredAngularDeferResult = {
+    slots: LoweredAngularDeferSlot[];
+    template: string;
+    transformed: boolean;
+};
+export declare const lowerAngularDeferSyntax: (template: string) => LoweredAngularDeferResult;

package/dist/absolutejs/src/angular/lowerServerIslands.d.ts

@@ -0,0 +1 @@
+export declare const lowerAngularServerIslands: (html: string) => Promise<string>;

package/dist/absolutejs/src/angular/pageHandler.d.ts

@@ -0,0 +1,26 @@
+import type { AngularPageImporter, AngularPagePropsOf } from '../../types/angular';
+import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
+type AngularPageRenderOptions = StreamingSlotEnhancerOptions & {
+    collectStreamingSlots?: boolean;
+};
+export type AngularPageRequestInput<Page = {
+    factory: (props: Record<never, never>) => unknown;
+}> = AngularPageRenderOptions & {
+    headTag?: `<head>${string}</head>`;
+    indexPath: string;
+    pagePath: string;
+} & (keyof AngularPagePropsOf<Page> extends never ? {
+    props?: NoInfer<AngularPagePropsOf<Page>>;
+} : {
+    props: NoInfer<AngularPagePropsOf<Page>>;
+});
+export type HandleAngularPageRequest = {
+    <Page = {
+        factory: (props: Record<never, never>) => unknown;
+    }>(input: AngularPageRequestInput<Page>): Promise<Response>;
+    <Props extends Record<string, unknown> = Record<never, never>>(Page: AngularPageImporter<Props>, pagePath: string, indexPath: string, headTag: `<head>${string}</head>` | undefined, ...args: AngularPageHandlerArgs<Props>): Promise<Response>;
+};
+type AngularPageHandlerArgs<Props extends Record<string, unknown>> = keyof Props extends never ? [props?: NoInfer<Props>, options?: AngularPageRenderOptions] : [props: NoInfer<Props>, options?: AngularPageRenderOptions];
+export declare const invalidateAngularSsrCache: () => void;
+export declare const handleAngularPageRequest: HandleAngularPageRequest;
+export {};

package/dist/absolutejs/src/angular/resolveAngularPackage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolve an Angular package path from process.cwd()/node_modules/ first,
+ * falling back to the bare specifier. This prevents Bun's baked import.meta.dir
+ * from resolving Angular packages from the absolutejs source tree instead of
+ * the consumer's project when running from a published npm package.
+ */
+export declare const resolveAngularPackage: (specifier: string) => string;

package/dist/absolutejs/src/angular/ssrRender.d.ts

@@ -0,0 +1,16 @@
+import type { EnvironmentProviders, Provider, Type } from '@angular/core';
+import type { AngularDeps, CachedRouteData, SsrDepsResult } from '../../types/angular';
+export declare const cacheRouteData: (pagePath: string, data: CachedRouteData) => void;
+export declare const getCachedRouteData: (pagePath: string) => CachedRouteData | undefined;
+export declare const buildDeps: (ssrResult: SsrDepsResult | null, baseDeps: AngularDeps) => AngularDeps;
+export declare const buildProviders: (deps: AngularDeps, sanitizer: InstanceType<AngularDeps["DomSanitizer"]>, maybeProps: Record<string, unknown> | undefined, tokenMap: Map<string, unknown>) => (Provider | EnvironmentProviders | {
+    provide: unknown;
+    useValue: unknown;
+})[];
+export declare const clearSelectorCache: () => void;
+export declare const discoverTokens: (pageModule: Record<string, unknown>) => Map<string, unknown>;
+export declare const loadSsrDeps: (pagePath: string) => Promise<SsrDepsResult | null>;
+export declare const resolveSelector: (deps: AngularDeps, pagePath: string, PageComponent: Type<unknown>) => string;
+export declare const injectSsrScripts: (html: string, requestId: string, indexPath: string, props?: Record<string, unknown>) => string;
+export declare const renderAngularApp: (deps: AngularDeps, PageComponent: Type<unknown>, providers: (Provider | EnvironmentProviders)[], document: string | Document) => Promise<string>;
+export declare const withSuppressedAngularDevLogs: <T>(render: () => Promise<T>) => Promise<T>;

package/dist/absolutejs/src/angular/ssrSanitizer.d.ts

@@ -0,0 +1,3 @@
+import type { AngularDeps } from '../../types/angular';
+export declare const getSsrSanitizer: (deps: AngularDeps) => import("@angular/platform-browser").DomSanitizer;
+export declare const resetSsrSanitizer: () => void;

package/dist/absolutejs/src/build/angularLinkerPlugin.d.ts

@@ -0,0 +1,11 @@
+import type { BunPlugin } from 'bun';
+/**
+ * Bun bundler plugin that runs the Angular Linker on partially compiled
+ * Angular libraries at build time. Converts ɵɵngDeclare* declarations
+ * into fully AOT-compiled code so @angular/compiler is not shipped to
+ * the browser.
+ *
+ * Uses a disk cache keyed by file content hash — Babel only runs once
+ * per Angular package version. Subsequent builds are pure file reads.
+ */
+export declare const angularLinkerPlugin: BunPlugin;

package/dist/absolutejs/src/build/buildAngularVendor.d.ts

@@ -0,0 +1,4 @@
+/** Compute the deterministic vendor paths mapping (no build needed).
+ *  This can be called before vendor files exist on disk. */
+export declare const buildAngularVendor: (buildDir: string) => Promise<void>;
+export declare const computeAngularVendorPaths: () => Record<string, string>;

package/dist/absolutejs/src/build/buildDepVendor.d.ts

@@ -0,0 +1,2 @@
+export declare const buildDepVendor: (buildDir: string, directories: string[]) => Promise<Record<string, string>>;
+export declare const computeDepVendorPaths: (directories: string[]) => Promise<Record<string, string>>;

package/dist/absolutejs/src/build/buildReactVendor.d.ts

@@ -0,0 +1,8 @@
+/** Compute the deterministic vendor paths mapping (no build needed).
+ *  This can be called before vendor files exist on disk. */
+export declare const computeVendorPaths: () => Record<string, string>;
+/** Build React packages into stable vendor files (no content hash).
+ *  Output goes to {buildDir}/react/vendor/ with predictable names like
+ *  react.js, react-dom_client.js, etc. These files never change between
+ *  rebuilds, so the browser always loads React from a single source. */
+export declare const buildReactVendor: (buildDir: string) => Promise<void>;

package/dist/absolutejs/src/build/buildSvelteVendor.d.ts

@@ -0,0 +1,6 @@
+/** Build Svelte packages into stable vendor files (no content hash).
+ *  Output goes to {buildDir}/svelte/vendor/ with predictable names. */
+export declare const buildSvelteVendor: (buildDir: string) => Promise<void>;
+/** Compute the deterministic vendor paths mapping (no build needed).
+ *  This can be called before vendor files exist on disk. */
+export declare const computeSvelteVendorPaths: () => Record<string, string>;

package/dist/absolutejs/src/build/buildVueVendor.d.ts

@@ -0,0 +1,6 @@
+/** Build Vue packages into stable vendor files (no content hash).
+ *  Output goes to {buildDir}/vue/vendor/ with predictable names. */
+export declare const buildVueVendor: (buildDir: string) => Promise<void>;
+/** Compute the deterministic vendor paths mapping (no build needed).
+ *  This can be called before vendor files exist on disk. */
+export declare const computeVueVendorPaths: () => Record<string, string>;

package/dist/absolutejs/src/build/compileAngular.d.ts

@@ -0,0 +1,29 @@
+import type { CompilerOptions } from '@angular/compiler-cli';
+import ts from 'typescript';
+type AngularCompilerCache = {
+    host: ts.CompilerHost;
+    options: CompilerOptions;
+    configHash: string;
+    tsLibDir: string;
+    lastUsed: number;
+};
+declare global {
+    var __angularCompilerCache: AngularCompilerCache | undefined;
+}
+export declare const compileAngularFile: (inputPath: string, outDir: string) => Promise<string[]>;
+/** Angular HMR Runtime Layer (Level 3) — JIT-mode compilation for dev/HMR builds.
+ *  Uses ts.transpileModule() instead of Angular AOT performCompilation().
+ *  Inlines templateUrl → template and styleUrls → styles from disk.
+ *  Recursively transpiles all local imports so Bun's bundler can resolve them.
+ *  ~50-100ms for a tree of ~10 files vs ~500-700ms for AOT. */
+export declare const compileAngularFileJIT: (inputPath: string, outDir: string, rootDir?: string) => Promise<string[]>;
+export declare const compileAngular: (entryPoints: string[], outRoot: string, hmr?: boolean) => Promise<{
+    clientPaths: string[];
+    serverPaths: string[];
+    allIndexesUnchanged?: undefined;
+} | {
+    allIndexesUnchanged: boolean;
+    clientPaths: string[];
+    serverPaths: string[];
+}>;
+export {};

package/dist/absolutejs/src/build/compileSvelte.d.ts

@@ -0,0 +1,13 @@
+type Built = {
+    ssr: string;
+    client: string;
+    hasAwaitSlot: boolean;
+};
+type Cache = Map<string, Built>;
+export declare const clearSvelteCompilerCache: () => void;
+export declare const compileSvelte: (entryPoints: string[], svelteRoot: string, cache?: Cache, isDev?: boolean) => Promise<{
+    svelteClientPaths: string[];
+    svelteIndexPaths: string[];
+    svelteServerPaths: string[];
+}>;
+export {};

package/dist/absolutejs/src/build/compileVue.d.ts

@@ -0,0 +1,19 @@
+import type { SFCDescriptor } from '@vue/compiler-sfc';
+export type VueChangeType = 'style-only' | 'template-only' | 'script' | 'full';
+export declare const vueHmrMetadata: Map<string, {
+    hmrId: string;
+    changeType: VueChangeType;
+}>;
+export declare const clearVueHmrCaches: () => void;
+export declare const detectVueChangeType: (filePath: string, descriptor: SFCDescriptor) => "script" | "style-only" | "template-only" | "full";
+export declare const generateVueHmrId: (sourceFilePath: string, vueRootDir: string) => string;
+export declare const compileVue: (entryPoints: string[], vueRootDir: string, isDev?: boolean) => Promise<{
+    hmrMetadata: Map<string, {
+        hmrId: string;
+        changeType: VueChangeType;
+    }>;
+    vueClientPaths: string[];
+    vueCssPaths: string[];
+    vueIndexPaths: string[];
+    vueServerPaths: string[];
+}>;

package/dist/absolutejs/src/build/generateManifest.d.ts

@@ -0,0 +1,2 @@
+import { BuildArtifact } from 'bun';
+export declare const generateManifest: (outputs: BuildArtifact[], buildPath: string) => Record<string, string>;

package/dist/absolutejs/src/build/generateReactIndexes.d.ts

@@ -0,0 +1 @@
+export declare const generateReactIndexFiles: (reactPagesDirectory: string, reactIndexesDirectory: string, isDev?: boolean) => Promise<void>;

package/dist/absolutejs/src/build/htmlScriptHMRPlugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bun build plugin that wraps HTML/HTMX scripts with import.meta.hot support
+ * for granular HMR. This allows script changes to hot-reload independently
+ * without triggering a full HTML page rebuild.
+ */
+import type { BunPlugin } from 'bun';
+/**
+ * Creates a Bun build plugin that wraps HTML/HTMX scripts with HMR support
+ * @param htmlDir - The HTML directory path (normalized with forward slashes)
+ * @param htmxDir - The HTMX directory path (normalized with forward slashes)
+ * @returns Bun build plugin
+ */
+export declare const createHTMLScriptHMRPlugin: (htmlDir?: string, htmxDir?: string) => BunPlugin;

package/dist/absolutejs/src/build/islandEntries.d.ts

@@ -0,0 +1,32 @@
+import type { IslandFramework, IslandRegistryInput } from '../../types/island';
+type IslandBuildEntry = {
+    component: string;
+    entryPath: string;
+    framework: IslandFramework;
+};
+type IslandDefinition = {
+    buildReference: {
+        export?: string;
+        source: string;
+    } | null;
+    component: string;
+    framework: IslandFramework;
+};
+type IslandRegistryBuildInfo = {
+    definitions: IslandDefinition[];
+    hasNamedExport: boolean;
+    registry: IslandRegistryInput;
+    resolvedRegistryPath: string;
+};
+type IslandEntryPathMaps = Partial<Record<IslandFramework, Map<string, string>>>;
+export declare const collectIslandFrameworkSources: (buildInfo: IslandRegistryBuildInfo) => Partial<Record<IslandFramework, string[]>>;
+export declare const generateIslandEntryPoints: ({ buildInfo, buildPath, clientPathMaps }: {
+    buildInfo: IslandRegistryBuildInfo;
+    buildPath: string;
+    clientPathMaps?: IslandEntryPathMaps;
+}) => Promise<{
+    entries: IslandBuildEntry[];
+    generatedRoot: string;
+}>;
+export declare const loadIslandRegistryBuildInfo: (registryPath: string) => Promise<IslandRegistryBuildInfo>;
+export {};

package/dist/absolutejs/src/build/nativeRewrite.d.ts

@@ -0,0 +1,5 @@
+/** Native Zig import rewriter — 15x faster than JS regex on large files.
+ *  Falls back to JS if the native addon isn't available (Windows, missing .so). */
+/** Rewrite import specifiers in a string using the native Zig scanner.
+ *  Returns the rewritten string, or null if native isn't available. */
+export declare const nativeRewriteImports: (content: string, replacements: [string, string][]) => string | null;

package/dist/absolutejs/src/build/optimizeHtmlImages.d.ts

@@ -0,0 +1,2 @@
+import type { ImageConfig } from '../../types/image';
+export declare const optimizeHtmlImages: (directory: string, config?: ImageConfig) => Promise<void>;

package/dist/absolutejs/src/build/outputLogs.d.ts

@@ -0,0 +1 @@
+export declare const outputLogs: (logs: (BuildMessage | ResolveMessage)[]) => void;

package/dist/absolutejs/src/build/resolvePackageImport.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve a bare module import (e.g. "@absolutejs/absolute/svelte/components/Image.svelte")
+ * to an absolute file path by reading the package's exports map in package.json.
+ *
+ * Returns the resolved absolute path, or null if the import can't be resolved.
+ */
+type ExportConditions = 'browser' | 'import';
+export declare const resolvePackageImport: (specifier: string, conditions?: ExportConditions[]) => string | null;
+export {};

package/dist/absolutejs/src/build/rewriteImports.d.ts

@@ -0,0 +1,7 @@
+/** Post-process bundled output files to rewrite bare specifiers
+ *  (e.g. `from "@angular/core"`) to stable vendor paths
+ *  (e.g. `from "/angular/vendor/angular_core.js"`).
+ *
+ *  Uses native Zig scanner (15x faster) when available, falls back
+ *  to JS regex on Windows or when the native addon is missing. */
+export declare const rewriteImports: (outputPaths: string[], vendorPaths: Record<string, string>) => Promise<void>;

package/dist/absolutejs/src/build/rewriteReactImports.d.ts

@@ -0,0 +1,7 @@
+/** Post-process bundled output files to rewrite bare React specifiers
+ *  (e.g. `from "react"`) to stable vendor paths (e.g. `from "/vendor/react.js"`).
+ *
+ *  Uses native Zig scanner when available (15x faster on large files),
+ *  falls back to JS regex on Windows or when native addon is missing. */
+export declare const patchRefreshGlobals: (outputPaths: string[]) => Promise<void>;
+export declare const rewriteReactImports: (outputPaths: string[], vendorPaths: Record<string, string>) => Promise<void>;

package/dist/absolutejs/src/build/scanConventions.d.ts

@@ -0,0 +1,5 @@
+import type { FrameworkConventionEntry } from '../../types/conventions';
+export declare const scanConventions: (pagesDir: string, pattern: string) => Promise<{
+    conventions: FrameworkConventionEntry | undefined;
+    pageFiles: string[];
+}>;

package/dist/absolutejs/src/build/scanCssEntryPoints.d.ts

@@ -0,0 +1 @@
+export declare const scanCssEntryPoints: (dir: string, ignore?: string[]) => Promise<string[]>;

package/dist/absolutejs/src/build/scanEntryPoints.d.ts

@@ -0,0 +1 @@
+export declare const scanEntryPoints: (dir: string, pattern: string) => Promise<string[]>;

package/dist/absolutejs/src/build/staticIslandPages.d.ts

@@ -0,0 +1,9 @@
+import type { IslandRegistryInput } from '../../types/island';
+export declare const transformStaticPageHtml: (originalHtml: string, registry: IslandRegistryInput) => Promise<string>;
+export declare const transformStaticHTMXStreamSlotHtml: (originalHtml: string) => string;
+export declare const transformStaticStreamingSlotHtml: (originalHtml: string) => string;
+export declare const transformCurrentStaticPageHtml: (html: string, options?: {
+    enableHTMXStreaming?: boolean;
+    enableStaticStreaming?: boolean;
+}) => Promise<string>;
+export declare const transformStaticPagesWithIslands: (registryPath: string | undefined, pagePaths: string[]) => Promise<void>;

package/dist/absolutejs/src/build/updateAssetPaths.d.ts

@@ -0,0 +1 @@
+export declare const updateAssetPaths: (manifest: Record<string, string>, directory: string) => Promise<void>;

package/dist/absolutejs/src/build/wrapHTMLScript.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Wraps HTML/HTMX TypeScript/JavaScript scripts with import.meta.hot support
+ * for granular HMR updates. This allows script changes to hot-reload
+ * without triggering a full HTML page rebuild.
+ *
+ * The wrapper is minimal - it just adds import.meta.hot.accept() so Bun
+ * knows this module can be hot-reloaded. Event listener cleanup is handled
+ * by the HMR client (cloning elements before script re-execution).
+ */
+/**
+ * Wrap a script with HMR support using Bun's import.meta.hot API
+ * @param code - The original script code
+ * @param scriptId - Unique identifier for this script (usually the file path)
+ * @returns Wrapped code with HMR support
+ */
+export declare const isHTMLScript: (filePath: string, htmlDir?: string, htmxDir?: string) => boolean;
+export declare const wrapHTMLScriptWithHMR: (code: string, scriptId: string) => string;

package/dist/absolutejs/src/cli/scripts/telemetry.d.ts

@@ -0,0 +1,5 @@
+import type { TelemetryConfig } from '../../../types/telemetry';
+export declare const getTelemetryConfig: () => TelemetryConfig | null;
+export declare const isTelemetryEnabled: () => boolean;
+export declare const saveTelemetryConfig: (config: TelemetryConfig) => void;
+export declare const telemetry: (args: string[]) => void;

package/dist/absolutejs/src/cli/telemetryEvent.d.ts

@@ -0,0 +1 @@
+export declare const sendTelemetryEvent: (event: string, payload: Record<string, unknown>) => void;

package/dist/absolutejs/src/client/islandStore.d.ts

@@ -0,0 +1,22 @@
+import { type StateCreator, type StoreApi } from 'zustand/vanilla';
+export type IslandStoreState = object;
+type IslandStoreSnapshot = Record<string, unknown>;
+export type IslandStateSnapshot = Record<string, IslandStoreSnapshot>;
+type AnyIslandStore = StoreApi<object>;
+type IslandStoreInstance = {
+    applyExternalSnapshot: (snapshot: IslandStoreSnapshot) => void;
+    store: AnyIslandStore;
+};
+declare const ABSOLUTE_ISLAND_STATE = "__ABS_ISLAND_STATE__";
+declare const ABSOLUTE_ISLAND_STORES = "__ABS_ISLAND_STORES__";
+declare global {
+    var __ABS_ISLAND_STATE__: IslandStateSnapshot | undefined;
+    var __ABS_ISLAND_STORES__: Map<string, Set<IslandStoreInstance>> | undefined;
+}
+export declare const createIslandStore: <TState extends IslandStoreState, TActions extends object>(storeId: string, initialState: TState, createState: StateCreator<TState, [], [], TActions>) => StoreApi<Omit<TState, keyof TActions> & TActions>;
+export declare const getIslandStoreServerSnapshot: <TState extends IslandStoreState, TSelected>(store: StoreApi<TState>, selector: (state: TState) => TSelected) => TSelected;
+export declare const initializeIslandStores: (state: IslandStateSnapshot) => void;
+export declare const readIslandStore: <TState extends IslandStoreState, TSelected>(store: StoreApi<TState>, selector: (state: TState) => TSelected) => TSelected;
+export declare const resetIslandStoreForTesting: () => void;
+export declare const subscribeIslandStore: <TState extends IslandStoreState, TSelected>(store: StoreApi<TState>, selector: (state: TState) => TSelected, listener: (value: TSelected) => void) => () => void;
+export { ABSOLUTE_ISLAND_STATE, ABSOLUTE_ISLAND_STORES };

package/dist/absolutejs/src/client/streamSwap.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Window {
+        __ABS_SLOT_ENQUEUE__?: (id: string, payload: unknown) => void;
+        __ABS_SLOT_FLUSH__?: () => void;
+        __ABS_SLOT_CONSUMERS__?: Record<string, ((payload: unknown) => boolean | void) | undefined>;
+        __ABS_SLOT_HYDRATION_PENDING__?: boolean;
+        __ABS_SLOT_PENDING__?: Record<string, unknown>;
+        __ABS_SLOT_RUNTIME__?: boolean;
+    }
+}
+export declare const getStreamSwapRuntimeScript: () => string;

package/dist/absolutejs/src/constants.d.ts

@@ -0,0 +1,60 @@
+export declare const ANGULAR_INIT_TIMEOUT_MS = 500;
+export declare const ANSI_ESCAPE_LENGTH = 3;
+export declare const ASCII_SPACE = 32;
+export declare const BASE_36_RADIX = 36;
+export declare const BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet";
+export declare const BODY_SLICE_LENGTH = 2000;
+export declare const BYTES_PER_KILOBYTE = 1024;
+export declare const CLI_ARGS_OFFSET = 3;
+export declare const CSS_ERROR_RESOLVE_DELAY_MS = 50;
+export declare const CSS_MAX_CHECK_ATTEMPTS = 10;
+export declare const CSS_MAX_PARSE_TIMEOUT_MS = 500;
+export declare const CSS_SHEET_READY_TIMEOUT_MS = 100;
+export declare const DEFAULT_CHUNK_SIZE = 16384;
+export declare const DEFAULT_DEBOUNCE_MS = 15;
+export declare const DEFAULT_PORT = 3000;
+export declare const DEV_SERVER_RESTART_DEBOUNCE_MS = 100;
+export declare const DOM_UPDATE_DELAY_MS = 50;
+export declare const FILE_PROTOCOL_PREFIX_LENGTH = 7;
+export declare const FOCUS_ID_PREFIX_LENGTH = 3;
+export declare const FOCUS_IDX_PREFIX_LENGTH = 4;
+export declare const FOCUS_NAME_PREFIX_LENGTH = 5;
+export declare const HMR_UPDATE_TIMEOUT_MS = 2000;
+export declare const HOOK_SIGNATURE_LENGTH = 12;
+export declare const EXCLUDE_LAST_OFFSET = -1;
+export declare const HTTP_STATUS_OK = 200;
+export declare const HTTP_STATUS_BAD_REQUEST = 400;
+export declare const HTTP_STATUS_NOT_FOUND = 404;
+export declare const HOURS_IN_DAY = 24;
+export declare const HOURS_IN_HALF_DAY = 12;
+export declare const MAX_ERROR_LENGTH = 200;
+export declare const MAX_RECONNECT_ATTEMPTS = 60;
+export declare const MILLISECONDS_IN_A_SECOND = 1000;
+export declare const MINUTES_IN_AN_HOUR = 60;
+export declare const SECONDS_IN_A_MINUTE = 60;
+export declare const MILLISECONDS_IN_A_MINUTE: number;
+export declare const MILLISECONDS_IN_A_DAY: number;
+export declare const OVERLAY_FADE_DURATION_MS = 150;
+export declare const PING_INTERVAL_MS = 30000;
+export declare const RAF_BATCH_COUNT = 3;
+export declare const RANDOM_ID_END_INDEX = 11;
+export declare const REBUILD_BATCH_DELAY_MS = 10;
+export declare const REBUILD_RELOAD_DELAY_MS = 200;
+export declare const RECONNECT_INITIAL_DELAY_MS = 500;
+export declare const RECONNECT_POLL_INTERVAL_MS = 300;
+export declare const RAG_CHUNK_ID_PAD_LENGTH = 3;
+export declare const RAG_DOCUMENT_ID_PREVIEW_LENGTH = 32;
+export declare const RAG_DOCUMENT_SLUG_MAX_LENGTH = 48;
+export declare const RAG_MIN_CHUNK_LENGTH_FLOOR = 120;
+export declare const RAG_NATIVE_QUERY_CANDIDATE_LIMIT = 1000;
+export declare const RAG_SEARCH_SCORE_DECIMAL_PLACES = 3;
+export declare const RAG_VECTOR_DIMENSIONS_DEFAULT = 24;
+export declare const REACT_STREAM_SLOT_FAST_DELAY_MS = 5;
+export declare const REACT_STREAM_SLOT_SLOW_DELAY_MS = 20;
+export declare const SIGINT_EXIT_CODE = 130;
+export declare const SIGTERM_EXIT_CODE = 143;
+export declare const SVELTE_CSS_LOAD_TIMEOUT_MS = 500;
+export declare const TIME_PRECISION = 2;
+export declare const TWO_THIRDS: number;
+export declare const UNFOUND_INDEX = -1;
+export declare const WEBSOCKET_NORMAL_CLOSURE = 1000;

package/dist/absolutejs/src/core/build.d.ts

@@ -0,0 +1,9 @@
+import type { ConventionsMap } from '../../types/conventions';
+import type { BuildConfig } from '../../types/build';
+export declare const build: ({ buildDirectory, assetsDirectory, publicDirectory, islands, reactDirectory, htmlDirectory, htmxDirectory, angularDirectory, svelteDirectory, vueDirectory, stylesConfig, tailwind, options, incrementalFiles, mode }: BuildConfig) => Promise<{
+    conventions?: undefined;
+    manifest?: undefined;
+} | {
+    conventions: ConventionsMap;
+    manifest: Record<string, string>;
+}>;

package/dist/absolutejs/src/core/currentIslandRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { IslandRegistryInput } from '../../types/island';
+declare global {
+    var __absoluteIslandRegistry: IslandRegistryInput | undefined;
+}
+export declare const getCurrentIslandRegistry: () => Partial<Record<import("..").IslandFramework, Record<string, unknown>>> | undefined;
+export declare const requireCurrentIslandRegistry: () => Partial<Record<import("..").IslandFramework, Record<string, unknown>>>;
+export declare const setCurrentIslandRegistry: (registry: IslandRegistryInput | undefined) => void;