@absolutejs/absolute 0.19.0-beta.1043 → 0.19.0-beta.1044

package/dist/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/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/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/src/build/chainInlineSourcemaps.d.ts

@@ -0,0 +1,13 @@
+type SourceMap = {
+    version: 3;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    names: string[];
+    mappings: string;
+};
+export declare const buildLineRemap: (before: string, after: string) => number[];
+export declare const inlineLineMapComment: (sourcePath: string, sourceContent: string, generatedContent: string) => string;
+export declare const remapGeneratedLines: (mappings: string, lineRemap: number[]) => string;
+export declare const chainSourcemap: (outer: SourceMap, fetchInner: (sourcePath: string) => SourceMap | null) => SourceMap;
+export declare const chainBundleInlineSourcemap: (bundleFilePath: string) => void;
+export {};

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

@@ -0,0 +1,40 @@
+import type { StylePreprocessorConfig } from '../../types/build';
+export declare const compileAngularFiles: (inputPaths: string[], outDir: string, stylePreprocessors?: StylePreprocessorConfig) => Promise<string[]>;
+export declare const compileAngularFile: (inputPath: string, outDir: string, stylePreprocessors?: StylePreprocessorConfig) => Promise<string[]>;
+export declare const invalidateAngularJitCache: (filePath: string) => void;
+/** 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, stylePreprocessors?: StylePreprocessorConfig, cacheBuster?: string) => Promise<string[]>;
+/** Build-time providers info threaded down from `runAngularHandlerScan`.
+ *  When present, `compileAngular` injects an `export const providers = [...]`
+ *  declaration directly into each page's compiled server output instead
+ *  of relying on a sibling `.providers.ts` file. Injecting in-place
+ *  avoids the circular ESM dependency that arises when a router page
+ *  exports `routes` (`.providers.ts` would import `routes` from the
+ *  page, the page server output would re-export `providers` from
+ *  `.providers.ts` — circular; `provideRouter(undefined, ...)` then
+ *  throws NG04014 at SSR bootstrap). */
+export type AngularProvidersInjection = {
+    /** Source `.ts` path of the user's `angular.providers` binding, or null
+     *  when no global binding is configured. Router pages still get
+     *  `provideRouter(routes)` + `APP_BASE_HREF` injected without it — the
+     *  global `appProviders` spread is simply omitted. */
+    appProvidersSource: string | null;
+    /** Source `.ts` path → page metadata for every page the scanner saw. */
+    pagesByFile: Map<string, {
+        hasRoutes: boolean;
+        basePath: string | null;
+    }>;
+};
+export declare const compileAngular: (entryPoints: string[], outRoot: string, hmr?: boolean, stylePreprocessors?: StylePreprocessorConfig, providersInjection?: AngularProvidersInjection) => Promise<{
+    clientPaths: string[];
+    serverPaths: string[];
+    allIndexesUnchanged?: undefined;
+} | {
+    allIndexesUnchanged: boolean;
+    clientPaths: string[];
+    serverPaths: string[];
+}>;

package/dist/src/build/compileEmber.d.ts

@@ -0,0 +1,43 @@
+import { basename, dirname } from 'node:path';
+/**
+ * Compile a single Ember page entry. Returns the absolute paths of the
+ * server-side bundled output and the client-side raw module.
+ *
+ *  Server side: full Bun.build pass that inlines the Glimmer runtime,
+ *  simple-dom, and the renderer. The output exports `renderToHTML(props)`
+ *  which the page handler calls. Bundling everything into one file
+ *  guarantees a single state-bearing module instance — no "two copies
+ *  of @glimmer/runtime" hazard.
+ *
+ *  Client side: just the transpiled module (no bundle). The framework's
+ *  client bundle pass picks it up alongside other client entries and
+ *  externalizes the Ember runtime to the vendor URLs.
+ */
+export declare const compileEmberFile: (entry: string, compiledRoot: string, cwd?: string) => Promise<{
+    clientPath: string;
+    serverPath: string;
+}>;
+/**
+ * Batch-compile every entry in `entries`. Mirrors `compileSvelte`'s
+ * shape so `core/build.ts` can call it the same way.
+ */
+export declare const compileEmber: (entries: string[], emberDir: string, cwd?: string, _hmr?: boolean) => Promise<{
+    clientPaths: string[];
+    serverPaths: string[];
+}>;
+/**
+ * Hot path used by the dev module server: compile a single entry into
+ * a tmp dir and return the resulting JS source string. Phase 1 doesn't
+ * implement caching here; phase 3 will.
+ */
+export declare const compileEmberFileSource: (entry: string) => Promise<string>;
+/**
+ * Match the `compileSvelte` API surface so the dev rebuilder can call
+ * a stable name. Phase 1 returns the entry directory unchanged — caching
+ * lives in `compileEmber` itself, not in a separate cache layer.
+ */
+export declare const clearEmberCompilerCache: () => void;
+export declare const getEmberCompiledRoot: (_emberDir?: string) => string;
+export declare const getEmberServerCompiledDir: (emberDir: string) => string;
+export declare const getEmberClientCompiledDir: (emberDir: string) => string;
+export { dirname, basename };

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

@@ -0,0 +1,14 @@
+import type { StylePreprocessorConfig } from '../../types/build';
+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, stylePreprocessors?: StylePreprocessorConfig) => Promise<{
+    svelteClientPaths: string[];
+    svelteIndexPaths: string[];
+    svelteServerPaths: string[];
+}>;
+export {};

package/dist/src/build/compileTailwind.d.ts

@@ -0,0 +1,5 @@
+import type { BuildConfig, StylePreprocessorConfig, TailwindConfig } from '../../types/build';
+export declare const computeFrameworkTailwindSources: (config: BuildConfig) => string[];
+export declare const isTailwindCandidate: (filePath: string) => boolean;
+export declare const compileTailwind: (input: string, output: string, buildPath: string, styleTransformConfig?: StylePreprocessorConfig, extraSources?: string[], changedFiles?: string[]) => Promise<void>;
+export declare const compileTailwindConfig: (tailwind: TailwindConfig, buildPath: string, styleTransformConfig?: StylePreprocessorConfig, extraSources?: string[], changedFiles?: string[]) => Promise<void>;

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

@@ -0,0 +1,22 @@
+import type { SFCDescriptor } from '@vue/compiler-sfc';
+import { type ParsedVueSpaRoute } from './parseVueSpaRoutes';
+import type { StylePreprocessorConfig } from '../../types/build';
+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" | "template-only" | "full" | "style-only";
+export declare const generateVueHmrId: (sourceFilePath: string, vueRootDir: string) => string;
+export declare const compileVue: (entryPoints: string[], vueRootDir: string, isDev?: boolean, stylePreprocessors?: StylePreprocessorConfig, ssrOnlyEntries?: ReadonlySet<string>) => Promise<{
+    hmrMetadata: Map<string, {
+        hmrId: string;
+        changeType: VueChangeType;
+    }>;
+    vueClientPaths: string[];
+    vueCssPaths: string[];
+    vueIndexPaths: string[];
+    vueServerPaths: string[];
+    vueSpaRoutesBySource: Map<string, ParsedVueSpaRoute[]>;
+}>;

package/dist/src/build/externalAssetPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { BunPlugin } from 'bun';
+export declare const createExternalAssetPlugin: (outDir: string, userSourceRoots?: string[]) => BunPlugin;

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

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

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

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

package/dist/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/src/build/index.d.ts

@@ -0,0 +1,2 @@
+export { compileTailwind, compileTailwindConfig, isTailwindCandidate } from './compileTailwind';
+export { disposeTailwindCompiler, incrementalTailwindBuild, warmTailwindCompiler } from './tailwindCompiler';

package/dist/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/src/build/islandRegistryTransform.d.ts

@@ -0,0 +1,17 @@
+import type { BunPlugin } from 'bun';
+import type { IslandFramework } from '../../types/island';
+type IslandDefinitionLite = {
+    buildReference: {
+        export?: string;
+        source: string;
+    } | null;
+    component: string;
+    framework: IslandFramework;
+};
+export type IslandRegistryTransformInfo = {
+    definitions: IslandDefinitionLite[];
+    resolvedRegistryPath: string;
+};
+export declare const transformIslandRegistrySource: (source: string, filePath: string, info: IslandRegistryTransformInfo) => string | null;
+export declare const createIslandRegistryDefinitionPlugin: (info: IslandRegistryTransformInfo) => BunPlugin;
+export {};

package/dist/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/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/src/build/outputLogs.d.ts

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

package/dist/src/build/parseAngularConfigImports.d.ts

@@ -0,0 +1,9 @@
+export type AngularProvidersImport = {
+    /** Local binding name as referenced in the config (e.g. `appProviders`). */
+    bindingName: string;
+    /** Original exported name on the source module. */
+    importedName: string;
+    /** Resolved absolute path to the providers module (no extension). */
+    absolutePath: string;
+};
+export declare const parseAngularProvidersImport: (projectRoot: string) => AngularProvidersImport | null;

package/dist/src/build/parseVueSpaRoutes.d.ts

@@ -0,0 +1,20 @@
+/** Extract SPA child routes from a Vue page's source.
+ *
+ *  Looks for `export const routes = defineRoutes([ ... ])` and parses
+ *  each entry's `{ path, component: () => import('./X.vue') }` shape
+ *  into a `{ path, importPath }` pair. The result drives the per-route
+ *  CSS side-manifest emitted in `core/build.ts` so the SSR handler can
+ *  inline the matched child route's compiled CSS (see
+ *  `utils/spaRouteCss.ts` for the runtime side).
+ *
+ *  Regex-based on purpose: the supported shape is single-statement
+ *  array-of-object-literals, which is the only form `defineRoutes` is
+ *  documented to take. AST parsing would catch a few exotic edge cases
+ *  but adds a dependency on every page compile; the failure mode of a
+ *  miss is "child route CSS isn't inlined for that route", same as
+ *  pre-feature behaviour, so a loose regex is the right trade-off. */
+export type ParsedVueSpaRoute = {
+    path: string;
+    importPath: string;
+};
+export declare const parseVueSpaRoutes: (source: string) => ParsedVueSpaRoute[];

package/dist/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/src/build/rewriteImports.d.ts

@@ -0,0 +1,8 @@
+/** Compatibility shim — the rewrite logic moved to
+ *  `rewriteImportsPlugin.ts` where it runs in-pipeline against
+ *  `BuildArtifact[]` straight off `Bun.build()`'s result. Existing callers
+ *  that still pass a list of file paths route through this thin wrapper.
+ *  The new in-pipeline call site is `rewriteBuildOutputs`/`buildWithImportRewrite`
+ *  in `rewriteImportsPlugin.ts`. */
+export declare const rewriteImports: (outputPaths: string[], vendorPaths: Record<string, string>) => Promise<void>;
+export declare const rewriteVendorDirectories: (vendorDirs: string[], vendorPaths: Record<string, string>) => Promise<void>;

package/dist/src/build/rewriteImportsPlugin.d.ts

@@ -0,0 +1,48 @@
+/** In-pipeline import rewriter for Bun.build outputs.
+ *
+ *  Replaces the previous post-build `rewriteImports` + `rewriteVendorDirectories`
+ *  passes that walked file paths captured at scheduling time and read them off
+ *  disk later — a race window where the next rebuild could sweep a path between
+ *  capture and read, producing ENOENT.
+ *
+ *  Now: the rewrite operates on the `BuildArtifact` outputs returned by
+ *  `Bun.build()` itself, in the same await chain. Each output's content is
+ *  transformed (using the native Zig scanner when available, falling back to
+ *  the JS regex implementation), then written back to disk. The standalone
+ *  iteration over a captured path list goes away. */
+import type { BuildArtifact, BuildOutput } from 'bun';
+/** JS fallback: regex-based import rewriting. */
+export declare const jsRewriteImports: (content: string, replacements: [string, string][]) => string;
+/** Apply the bare-specifier → vendor-URL rewrite to a single chunk of text. */
+export declare const rewriteImportsInContent: (content: string, vendorPaths: Record<string, string>) => string;
+/** Workaround for a Bun bundler bug: when a module does both
+ *  `import { x } from 'X'` AND `export * from 'X'`, and `X` is externalized,
+ *  Bun synthesizes a `__reExport(exports_Y, ns)` call but drops the
+ *  corresponding `import * as ns from "X"` declaration. The resulting chunk
+ *  references an undeclared identifier and crashes at module evaluation.
+ *
+ *  Detects the pattern and injects the missing namespace import. The source
+ *  path is recovered from a sibling named-import in the same chunk (Bun keeps
+ *  that intact). */
+export declare const fixMissingReExportNamespacesInContent: (content: string) => string;
+/** In-pipeline output rewrite. Reads each emitted .js artifact, applies the
+ *  rewrite, and writes back. Operates on `BuildArtifact[]` straight off
+ *  `Bun.build()`'s result so paths are guaranteed-current — no race window. */
+export declare const rewriteBuildOutputs: (outputs: BuildArtifact[], vendorPaths: Record<string, string>) => Promise<void>;
+/** Like `rewriteBuildOutputs`, but takes a separate per-artifact resolver to
+ *  produce path maps. Used for the SSR-side @angular/* rewrite which uses
+ *  paths relative to each artifact's directory. */
+export declare const rewriteBuildOutputsWith: (outputs: BuildArtifact[], resolveVendorPaths: (artifact: BuildArtifact) => Record<string, string>) => Promise<void>;
+/** Apply the rewrite + re-export fix to every .js file inside a list of
+ *  vendor directories. Used after vendor builds where each pipeline emits
+ *  files that may externalize specifiers owned by another pipeline.
+ *
+ *  This still walks the directory because the cross-vendor rewrite happens
+ *  AFTER all vendor builds complete (so every framework's path map is
+ *  available) — it doesn't have a single `BuildArtifact[]` to operate on.
+ *  ENOENT during read/write is tolerated for the same race-protection
+ *  reason as the in-pipeline path. */
+export declare const rewriteVendorDirectories: (vendorDirs: string[], vendorPaths: Record<string, string>) => Promise<void>;
+/** Helper to wrap a `Bun.build` call so the rewrite happens in-pipeline.
+ *  Use as: `const result = await buildWithImportRewrite(bunBuild(config), vendorPaths)`. */
+export declare const buildWithImportRewrite: (pendingBuild: Promise<BuildOutput>, vendorPaths: Record<string, string>) => Promise<BuildOutput>;

package/dist/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/src/build/runAngularHandlerScan.d.ts

@@ -0,0 +1,7 @@
+import { type AngularHandlerCall } from './scanAngularHandlerCalls';
+import { type AngularPageRoutes } from './scanAngularPageRoutes';
+export type AngularHandlerScanResult = {
+    calls: AngularHandlerCall[];
+    pageRoutes: AngularPageRoutes[];
+};
+export declare const runAngularHandlerScan: (projectRoot: string, angularDirectory: string) => AngularHandlerScanResult;

package/dist/src/build/scanAngularHandlerCalls.d.ts

@@ -0,0 +1,13 @@
+export type AngularHandlerCall = {
+    /** File the call lives in. */
+    sourceFile: string;
+    /** Manifest key extracted from `pagePath: asset(manifest, "Foo")`. */
+    manifestKey: string;
+    /** Mount path from the surrounding `.get("/path", ...)` / `.post(...)`
+     *  Elysia chain. `null` when the call isn't directly inside such a
+     *  registration (rare but possible — e.g. inside a helper function). */
+    mountPath: string | null;
+};
+/** Walk every TypeScript file under `projectRoot` and return all
+ *  `handleAngularPageRequest({...})` calls found. */
+export declare const scanAngularHandlerCalls: (projectRoot: string) => AngularHandlerCall[];

package/dist/src/build/scanAngularPageRoutes.d.ts

@@ -0,0 +1,10 @@
+export type AngularPageRoutes = {
+    /** Absolute path of the page module. */
+    pageFile: string;
+    /** Manifest key (PascalCase of basename) — `home/home.ts` → `Home`. */
+    manifestKey: string;
+    /** True when the page module top-level declares
+     *  `export const routes` (or `let`/`var`). */
+    hasRoutes: boolean;
+};
+export declare const scanAngularPageRoutes: (pagesRoot: string) => AngularPageRoutes[];

package/dist/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/src/build/scanCssEntryPoints.d.ts

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

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

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

package/dist/src/build/scanRouteRegistrations.d.ts

@@ -0,0 +1,23 @@
+export type ExtractedRoute = {
+    /** Uppercase HTTP method, matching Elysia's runtime `route.method`. */
+    method: string;
+    /** Path argument literal — including leading slash, no host. */
+    path: string;
+    /** Verbatim source of the full `.method(...)` CallExpression. Used
+     *  downstream as a stand-in for the runtime handler so the existing
+     *  `isPageHandler` / `extractSitemapMetadata` substring checks work
+     *  unchanged against AST-discovered routes. */
+    handlerSource: string;
+};
+/** Walk every TypeScript source file under `projectRoot` and return the
+ *  Elysia route registrations found. Skip-dirs (`node_modules`, `dist`,
+ *  `build`, framework build caches, dotfile dirs) are excluded.
+ *
+ *  No path deduplication here on purpose: the same path (e.g. `/`) is
+ *  frequently registered by multiple plugins (one page route at the
+ *  root, several API sub-plugins under prefixes like `/v1/foo`). The
+ *  scanner has no way to know the prefix without tracing `.use()` /
+ *  `new Elysia({ prefix })`, but it doesn't need to — sitemap discovery
+ *  downstream filters by `isPageHandler` and then dedups by mount path,
+ *  so API duplicates are dropped naturally. */
+export declare const scanRouteRegistrations: (projectRoot: string) => ExtractedRoute[];

package/dist/src/build/scanVueSsrOnlyPages.d.ts

@@ -0,0 +1,6 @@
+/** Walk every TypeScript source file under `projectRoot` and collect
+ *  the set of Vue page manifest keys flagged `client: 'none'` at
+ *  registration time. The returned names correspond to the PascalCased
+ *  basenames of the .vue source files (e.g. `LandingPage` matches
+ *  `LandingPage.vue`). */
+export declare const scanVueSsrOnlyPages: (projectRoot: string) => Set<string>;

package/dist/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/src/build/stylePreprocessor.d.ts

@@ -0,0 +1,26 @@
+import type { BunPlugin } from 'bun';
+import type { PostCSSConfig, StylePreprocessorConfig } from '../../types/build';
+export declare const isPreprocessableStylePath: (filePath: string) => boolean;
+export declare const isStyleModulePath: (filePath: string) => boolean;
+export declare const isStylePath: (filePath: string) => boolean;
+export declare const getStyleBaseName: (filePath: string) => string;
+export declare const createStyleTransformConfig: (stylePreprocessors?: StylePreprocessorConfig, postcss?: PostCSSConfig) => StylePreprocessorConfig | undefined;
+export declare const addStyleImporter: (importerPath: string, stylePath: string) => void;
+export declare const findStyleEntriesImporting: (changedPath: string) => string[];
+export declare const recordStyleOutput: (entry: string, css: string) => boolean;
+export declare const forgetStyleEntry: (entry: string) => void;
+export declare const compileStyleSource: (filePath: string, source?: string, languageHint?: string, config?: StylePreprocessorConfig) => Promise<string>;
+export declare const createStylePreprocessorPlugin: (config?: StylePreprocessorConfig) => BunPlugin;
+export declare const stylePreprocessorPlugin: BunPlugin;
+export declare const createSvelteStylePreprocessor: (config?: StylePreprocessorConfig) => {
+    style: ({ attributes, content, filename }: {
+        attributes: Record<string, string | boolean>;
+        content: string;
+        filename?: string;
+    }) => Promise<{
+        code: string;
+    } | undefined>;
+};
+export declare const compileStyleFileIfNeeded: (filePath: string, config?: StylePreprocessorConfig) => Promise<string>;
+export declare const compileStyleFileIfNeededSync: (filePath: string, config?: StylePreprocessorConfig) => string;
+export declare const getCssOutputExtension: (filePath: string) => string;

package/dist/src/build/tailwindCompiler.d.ts

@@ -0,0 +1,8 @@
+import type { StylePreprocessorConfig, TailwindConfig } from '../../types/build';
+export declare const extractCandidates: (source: string) => Set<string>;
+export declare const disposeTailwindCompiler: (cssPath?: string) => void;
+export declare const incrementalTailwindBuild: (tailwind: TailwindConfig, buildPath: string, changedFiles: string[], styleTransformConfig?: StylePreprocessorConfig, extraSources?: string[]) => Promise<{
+    cssChanged: boolean;
+    durationMs: number;
+}>;
+export declare const warmTailwindCompiler: (tailwind: TailwindConfig, extraSources?: string[]) => Promise<void>;

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

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

package/dist/src/build/vendorEntrySource.d.ts

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

package/dist/src/build/verifyAngularCoreUniqueness.d.ts

@@ -0,0 +1,2 @@
+import type { BuildArtifact } from 'bun';
+export declare const verifyAngularCoreUniqueness: (artifacts: BuildArtifact[], serverOutDir: string | undefined, throwOnError: boolean) => Promise<void>;

package/dist/src/build/vueAutoRouterTransform.d.ts

@@ -0,0 +1 @@
+export declare const addAutoRouterSetupApp: (sourceContent: string) => string;

package/dist/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/src/build.d.ts

@@ -0,0 +1,2 @@
+export { build } from './core/build';
+export { devBuild } from './core/devBuild';

package/dist/src/cli/add/dependencies.d.ts

@@ -0,0 +1,12 @@
+import type { FrameworkKey } from '../generate/frameworkKey';
+type FrameworkDependencies = {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+};
+export declare const FRAMEWORK_DEPENDENCIES: Record<FrameworkKey, FrameworkDependencies>;
+export declare const frameworkDependencyNames: (framework: FrameworkKey) => string[];
+export declare const installFrameworkDependencies: (cwd: string, framework: FrameworkKey) => {
+    ok: boolean;
+    specs: string[];
+};
+export {};

package/dist/src/cli/cache.d.ts

@@ -0,0 +1,15 @@
+import type { ToolAdapter, ToolCacheData } from '../../types/tool';
+export declare const CACHE_DIR = ".absolutejs";
+export declare const MAX_FILES_PER_BATCH = 200;
+export declare const getChangedFiles: (adapter: ToolAdapter) => Promise<{
+    cache: ToolCacheData;
+    changed: string[];
+}>;
+export declare const hashConfigs: (configFiles: string[]) => Promise<string>;
+export declare const hashFile: (path: string) => Promise<string>;
+export declare const hashFiles: (paths: string[]) => Promise<{
+    [k: string]: string;
+}>;
+export declare const loadCache: (tool: string) => Promise<ToolCacheData | null>;
+export declare const runTool: (adapter: ToolAdapter, args: string[]) => Promise<void>;
+export declare const saveCache: (tool: string, data: ToolCacheData) => Promise<void>;

package/dist/src/cli/config/absolute/AbsoluteConfigPanel.d.ts

@@ -0,0 +1,6 @@
+import type { AbsoluteConfigState } from '../../../../types/absoluteConfig';
+type AbsoluteConfigPanelProps = {
+    state: AbsoluteConfigState;
+};
+export declare const AbsoluteConfigPanel: ({ state: initial }: AbsoluteConfigPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/cli/config/absolute/editAbsoluteConfig.d.ts

@@ -0,0 +1,5 @@
+import type { AbsoluteConfigEditRequest } from '../../../../types/absoluteConfig';
+export declare const applyAbsoluteConfigEdit: (configPath: string, request: AbsoluteConfigEditRequest) => {
+    message: string;
+    ok: boolean;
+};

package/dist/src/cli/config/absolute/resolveAbsoluteConfig.d.ts

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+export declare const findConfigPath: (cwd: string, override?: string) => string | null;
+export declare const findConfigObject: (sourceFile: ts.Node) => ts.ObjectLiteralExpression | null;
+export declare const parseConfigObject: (configPath: string) => {
+    object: ts.ObjectLiteralExpression | null;
+    text: string;
+};
+export declare const resolveAbsoluteConfigState: (cwd: string, override?: string) => {
+    available: boolean;
+    configPath: string | null;
+    current: Record<string, unknown>;
+    fields: import("../../../../types/config").FieldNode[];
+    opaqueKeys: string[];
+};

package/dist/src/cli/config/client.d.ts

@@ -0,0 +1 @@
+export {};