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

package/dist/src/dev/angular/vendor/translator/typescript_ast_factory.d.ts

@@ -1,66 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-import ts from 'typescript';
-import { AstFactory, BinaryOperator, BuiltInType, LeadingComment, ObjectLiteralProperty, Parameter, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
-/**
- * A TypeScript flavoured implementation of the AstFactory.
- */
-export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression, ts.TypeNode> {
-    private annotateForClosureCompiler;
-    private externalSourceFiles;
-    private readonly UNARY_OPERATORS;
-    private readonly BINARY_OPERATORS;
-    private readonly VAR_TYPES;
-    constructor(annotateForClosureCompiler: boolean);
-    attachComments: typeof attachComments;
-    createArrayLiteral: (elements?: readonly ts.Expression[], multiLine?: boolean) => ts.ArrayLiteralExpression;
-    createAssignment(target: ts.Expression, operator: BinaryOperator, value: ts.Expression): ts.Expression;
-    createBinaryExpression(leftOperand: ts.Expression, operator: BinaryOperator, rightOperand: ts.Expression): ts.Expression;
-    createBlock(body: ts.Statement[]): ts.Statement;
-    createCallExpression(callee: ts.Expression, args: ts.Expression[], pure: boolean): ts.Expression;
-    createConditional(condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.Expression;
-    createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
-    createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
-    createDynamicImport(url: string | ts.Expression): ts.CallExpression;
-    createFunctionDeclaration(functionName: string, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Statement;
-    createFunctionExpression(functionName: string | null, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Expression;
-    createArrowFunctionExpression(parameters: Parameter<ts.TypeNode>[], body: ts.Statement | ts.Expression): ts.Expression;
-    private createParameter;
-    createIdentifier: (text: string) => ts.Identifier;
-    createIfStatement(condition: ts.Expression, thenStatement: ts.Statement, elseStatement: ts.Statement | null): ts.Statement;
-    createLiteral(value: string | number | boolean | null | undefined): ts.Expression;
-    createNewExpression(expression: ts.Expression, args: ts.Expression[]): ts.Expression;
-    createObjectLiteral(properties: ObjectLiteralProperty<ts.Expression>[]): ts.Expression;
-    createParenthesizedExpression: (expression: ts.Expression) => ts.ParenthesizedExpression;
-    createPropertyAccess: (expression: ts.Expression, name: string | ts.MemberName) => ts.PropertyAccessExpression;
-    createSpreadElement: (expression: ts.Expression) => ts.SpreadElement;
-    createReturnStatement(expression: ts.Expression | null): ts.Statement;
-    createTaggedTemplate(tag: ts.Expression, template: TemplateLiteral<ts.Expression>): ts.Expression;
-    createTemplateLiteral(template: TemplateLiteral<ts.Expression>): ts.TemplateLiteral;
-    createThrowStatement: (expression: ts.Expression) => ts.ThrowStatement;
-    createTypeOfExpression: (expression: ts.Expression) => ts.TypeOfExpression;
-    createVoidExpression: (expression: ts.Expression) => ts.VoidExpression;
-    createUnaryExpression(operator: UnaryOperator, operand: ts.Expression): ts.Expression;
-    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, variableType: VariableDeclarationType, type: ts.TypeNode | null): ts.Statement;
-    createRegularExpressionLiteral(body: string, flags: string | null): ts.Expression;
-    setSourceMapRange<T extends ts.Node>(node: T, sourceMapRange: SourceMapRange | null): T;
-    createBuiltInType(type: BuiltInType): ts.TypeNode;
-    createExpressionType(expression: ts.Expression, typeParams: ts.TypeNode[] | null): ts.TypeNode;
-    createArrayType(elementType: ts.TypeNode): ts.TypeNode;
-    createMapType(valueType: ts.TypeNode): ts.TypeNode;
-    transplantType(type: ts.TypeNode): ts.TypeNode;
-}
-export declare function createTemplateMiddle(cooked: string, raw: string): ts.TemplateMiddle;
-export declare function createTemplateTail(cooked: string, raw: string): ts.TemplateTail;
-/**
- * Attach the given `leadingComments` to the `statement` node.
- *
- * @param statement The statement that will have comments attached.
- * @param leadingComments The comments to attach to the statement.
- */
-export declare function attachComments(statement: ts.Statement | ts.Expression, leadingComments: LeadingComment[]): void;

package/dist/src/dev/angular/vendor/translator/typescript_translator.d.ts

@@ -1,13 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-import * as o from '@angular/compiler';
-import ts from 'typescript';
-import { ImportGenerator } from './api/import_generator';
-import { TranslatorOptions } from './translator';
-export declare function translateExpression(contextFile: ts.SourceFile, expression: o.Expression, imports: ImportGenerator<ts.SourceFile, ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Expression;
-export declare function translateStatement(contextFile: ts.SourceFile, statement: o.Statement, imports: ImportGenerator<ts.SourceFile, ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Statement;

package/dist/src/dev/assetStore.d.ts

@@ -1,8 +0,0 @@
-/** Determine Content-Type from a file path extension */
-export declare const getMimeType: (filePath: string) => string;
-/** Upsert build outputs into the in-memory asset store.
- *  Evicts previous entries for the same logical asset (same base name,
- *  different hash) so stale paths don't accumulate. */
-export declare const cleanStaleAssets: (store: Map<string, Uint8Array>, manifest: Record<string, string>, buildDir: string) => Promise<void>;
-export declare const lookupAsset: (store: Map<string, Uint8Array>, path: string) => Uint8Array<ArrayBufferLike> | undefined;
-export declare const populateAssetStore: (store: Map<string, Uint8Array>, manifest: Record<string, string>, buildDir: string) => Promise<void>;

package/dist/src/dev/buildHMRClient.d.ts

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

package/dist/src/dev/clientManager.d.ts

@@ -1,33 +0,0 @@
-import type { FSWatcher } from 'fs';
-import { type DependencyGraph } from './dependencyGraph';
-import { type ModuleVersions } from './moduleVersionTracker';
-import type { HMRWebSocket } from '../../types/websocket';
-import type { BuildConfig } from '../../types/build';
-import { type ResolvedBuildPaths } from './configResolver';
-export type HMRState = {
-    connectedClients: Set<HMRWebSocket>;
-    activeFrameworks: Set<string>;
-    dependencyGraph: DependencyGraph;
-    isRebuilding: boolean;
-    rebuildQueue: Set<string>;
-    rebuildTimeout: NodeJS.Timeout | null;
-    fileChangeQueue: Map<string, string[]>;
-    debounceTimeout: NodeJS.Timeout | null;
-    fileHashes: Map<string, number>;
-    watchers: FSWatcher[];
-    moduleVersions: ModuleVersions;
-    sourceFileVersions: Map<string, number>;
-    config: BuildConfig;
-    resolvedPaths: ResolvedBuildPaths;
-    vueChangeTypes: Map<string, 'template-only' | 'script' | 'full'>;
-    assetStore: Map<string, Uint8Array>;
-    manifest: Record<string, string>;
-    rebuildCount: number;
-    lastHmrPath?: string;
-    lastHmrFramework?: string;
-    lastUserEditedFiles?: Set<string>;
-    initialBuildFailed?: boolean;
-};
-export declare const createHMRState: (config: BuildConfig) => HMRState;
-export declare const incrementSourceFileVersion: (state: HMRState, filePath: string) => number;
-export declare const incrementSourceFileVersions: (state: HMRState, filePaths: string[]) => void;

package/dist/src/dev/configResolver.d.ts

@@ -1,16 +0,0 @@
-import type { BuildConfig } from '../../types/build';
-/** Normalize and default build paths so HMR works outside the example app. */
-export declare const resolveBuildPaths: (config: BuildConfig) => {
-    angularDir: string | undefined;
-    assetsDir: string | undefined;
-    buildDir: string;
-    emberDir: string | undefined;
-    htmlDir: string | undefined;
-    htmxDir: string | undefined;
-    publicDir: string | undefined;
-    reactDir: string | undefined;
-    stylesDir: string | undefined;
-    svelteDir: string | undefined;
-    vueDir: string | undefined;
-};
-export type ResolvedBuildPaths = ReturnType<typeof resolveBuildPaths>;

package/dist/src/dev/dependencyGraph.d.ts

@@ -1,10 +0,0 @@
-export type DependencyGraph = {
-    dependents: Map<string, Set<string>>;
-    dependencies: Map<string, Set<string>>;
-};
-export declare const emptyDependencyGraph: DependencyGraph;
-export declare const addFileToGraph: (graph: DependencyGraph, filePath: string) => void;
-export declare const buildInitialDependencyGraph: (graph: DependencyGraph, directories: string[]) => void;
-export declare const extractDependencies: (filePath: string) => string[];
-export declare const getAffectedFiles: (graph: DependencyGraph, changedFile: string) => string[];
-export declare const removeFileFromGraph: (graph: DependencyGraph, filePath: string) => void;

package/dist/src/dev/devCert.d.ts

@@ -1,11 +0,0 @@
-export declare const hasMkcert: () => boolean;
-export declare const ensureDevCert: () => {
-    cert: string;
-    key: string;
-} | null;
-export declare const hasCert: () => boolean;
-export declare const loadDevCert: () => {
-    cert: string;
-    key: string;
-} | null;
-export declare const setupMkcert: () => boolean;

package/dist/src/dev/fileHashTracker.d.ts

@@ -1,2 +0,0 @@
-export declare const computeFileHash: (filePath: string) => number;
-export declare const hasFileChanged: (filePath: string, currentHash: number, previousHashes: Map<string, number>) => boolean;

package/dist/src/dev/fileWatcher.d.ts

@@ -1,4 +0,0 @@
-import type { BuildConfig } from '../../types/build';
-import type { HMRState } from './clientManager';
-export declare const addFileWatchers: (state: HMRState, paths: string[], onFileChange: (filePath: string) => void) => void;
-export declare const startFileWatching: (state: HMRState, config: BuildConfig, onFileChange: (filePath: string) => void) => void;

package/dist/src/dev/moduleMapper.d.ts

@@ -1,27 +0,0 @@
-import { type ComponentType } from './reactComponentClassifier';
-export type ModuleUpdate = {
-    sourceFile: string;
-    framework: string;
-    moduleKeys: string[];
-    modulePaths: Record<string, string>;
-    componentType?: ComponentType;
-};
-export declare const createModuleUpdates: (changedFiles: string[], framework: string, manifest: Record<string, string>, resolvedPaths?: {
-    reactDir?: string;
-    svelteDir?: string;
-    vueDir?: string;
-    angularDir?: string;
-}) => {
-    componentType: "server" | "client" | undefined;
-    framework: string;
-    moduleKeys: string[];
-    modulePaths: Record<string, string>;
-    sourceFile: string;
-}[];
-export declare const groupModuleUpdatesByFramework: (updates: ModuleUpdate[]) => Map<string, ModuleUpdate[]>;
-export declare const mapSourceFileToManifestKeys: (sourceFile: string, framework: string, resolvedPaths?: {
-    reactDir?: string;
-    svelteDir?: string;
-    vueDir?: string;
-    angularDir?: string;
-}) => string[];

package/dist/src/dev/moduleServer.d.ts

@@ -1,24 +0,0 @@
-import type { StylePreprocessorConfig } from '../../types/build';
-type ModuleServerConfig = {
-    projectRoot: string;
-    vendorPaths: Record<string, string>;
-    frameworkDirs?: {
-        angular?: string;
-        react?: string;
-        svelte?: string;
-        vue?: string;
-    };
-    stylePreprocessors?: StylePreprocessorConfig;
-};
-export declare const warnIfReactFastRefreshUnsupported: () => void;
-export declare const warmCompilers: (frameworks: {
-    svelte?: boolean;
-    vue?: boolean;
-}) => Promise<void>;
-export declare const createModuleServer: (config: ModuleServerConfig) => (pathname: string) => Promise<Response | undefined>;
-export declare const invalidateModule: (filePath: string) => void;
-export declare const warmCache: (pathname: string) => void;
-declare let globalModuleServer: ((pathname: string) => Promise<Response | undefined> | Response | undefined) | null;
-export declare const SRC_URL_PREFIX = "/@src/";
-export declare const setGlobalModuleServer: (handler: typeof globalModuleServer) => void;
-export {};

package/dist/src/dev/moduleVersionTracker.d.ts

@@ -1,7 +0,0 @@
-export type ModuleVersion = number;
-export type ModuleVersions = Map<string, ModuleVersion>;
-export declare const createModuleVersionTracker: () => Map<string, number>;
-export declare const getNextVersion: () => number;
-export declare const incrementModuleVersion: (versions: ModuleVersions, modulePath: string) => number;
-export declare const incrementModuleVersions: (versions: ModuleVersions, modulePaths: string[]) => Map<string, number>;
-export declare const serializeModuleVersions: (versions: ModuleVersions) => Record<string, number>;

package/dist/src/dev/pathUtils.d.ts

@@ -1,8 +0,0 @@
-import { BuildConfig } from '../../types/build';
-import type { ResolvedBuildPaths } from './configResolver';
-export declare const detectFramework: (filePath: string, resolved?: ResolvedBuildPaths) => "react" | "svelte" | "vue" | "angular" | "ember" | "html" | "unknown" | "ignored" | "styles" | "htmx" | "assets";
-export declare const getWatchPaths: (config: BuildConfig, resolved?: ResolvedBuildPaths) => string[];
-/** A path is ignored when it is NOT inside any of the configured
- *  positive watch roots, OR when it falls inside a hard-denied
- *  build/output subtree. The styles directory is always allowed. */
-export declare const shouldIgnorePath: (path: string, resolved?: ResolvedBuildPaths) => boolean;

package/dist/src/dev/reactComponentClassifier.d.ts

@@ -1,2 +0,0 @@
-export type ComponentType = 'client' | 'server';
-export declare const classifyComponent: (filePath: string) => "server" | "client";

package/dist/src/dev/rebuildTrigger.d.ts

@@ -1,11 +0,0 @@
-import type { BuildConfig } from '../../types/build';
-import { type HMRState } from './clientManager';
-export declare const queueFileChange: (state: HMRState, filePath: string, config: BuildConfig, onRebuildComplete: (result: {
-    manifest: Record<string, string>;
-    hmrState: HMRState;
-}) => void) => Promise<void>;
-export type AngularHmrTier = 0 | 1 | 2;
-export declare const triggerRebuild: (state: HMRState, config: BuildConfig, onRebuildComplete: (result: {
-    manifest: Record<string, string>;
-    hmrState: HMRState;
-}) => void, filesToRebuild?: string[]) => Promise<Record<string, string> | null>;

package/dist/src/dev/requestInspector.d.ts

@@ -1,43 +0,0 @@
-import { Elysia } from 'elysia';
-export declare const requestInspector: Elysia<"", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {
-    __absolute: {
-        requests: {
-            get: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: import("..").RequestRecord[];
-                };
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>;

package/dist/src/dev/serverEntryWatcher.d.ts

@@ -1,5 +0,0 @@
-declare global {
-    var __absoluteEntryWatcherStarted: boolean | undefined;
-}
-export declare const isAtomicWriteTemp: (filename: string) => boolean;
-export declare const startServerEntryWatcher: () => void;

package/dist/src/dev/simpleHTMLHMR.d.ts

@@ -1,4 +0,0 @@
-export declare const handleHTMLUpdate: (htmlFilePath: string) => Promise<string | {
-    body: string;
-    head: string | null;
-} | null>;

package/dist/src/dev/simpleHTMXHMR.d.ts

@@ -1,4 +0,0 @@
-export declare const handleHTMXUpdate: (htmxFilePath: string) => Promise<string | {
-    body: string;
-    head: string | null;
-} | null>;

package/dist/src/dev/transformCache.d.ts

@@ -1,22 +0,0 @@
-export declare const getTransformed: (filePath: string) => string | undefined;
-export declare const setTransformed: (filePath: string, content: string, mtime: number, imports?: string[]) => void;
-export declare const findNearestComponent: (filePath: string) => string | undefined;
-export declare const getInvalidationVersion: (filePath: string) => number;
-/**
- * Invalidate `filePath` and every transitive importer.
- *
- * BFS up the reverse-import graph; for each visited file we (1) drop
- * its transform cache so the next request re-transpiles, and (2) bump
- * its invalidation version so `srcUrl()` emits a fresh `?v=` token —
- * forcing the browser to refetch even when the importer's mtime is
- * unchanged. Bumping versions on transitive importers (not just the
- * originally-changed file) is the load-bearing piece: without it, a
- * page that imports a service via two intermediate components keeps
- * resolving the page module under its old `?v=`, the page bundle's
- * internal `/@src/` references stay pointed at stale URLs, and rapid
- * HMR cycles wedge the browser bundle until the dev server restarts.
- *
- * Cycles are tolerated via the `visited` set.
- */
-export declare const invalidate: (filePath: string) => void;
-export declare const invalidateAll: () => void;

package/dist/src/dev/tunnel/client.d.ts

@@ -1,20 +0,0 @@
-type TunnelClientOptions = {
-    /** Public relay base URL, e.g. `https://my-relay.ondigitalocean.app`. */
-    relayUrl: string;
-    /** Shared secret matching the relay's token. */
-    token: string;
-    /** Local app origin to replay requests against, e.g. `http://localhost:3000`. */
-    localOrigin: string;
-    /** Called once the relay confirms the public URL is live. */
-    onReady?: (publicUrl: string) => void;
-};
-/**
- * Start the dev-side tunnel client. Dials the relay's control socket and
- * replays each forwarded request against the local app, streaming responses
- * back. Auto-reconnects so an HMR restart or a relay blip self-heals.
- */
-export declare const startTunnelClient: (options: TunnelClientOptions) => {
-    publicUrl: string;
-    close(): void;
-};
-export {};

package/dist/src/dev/tunnel/protocol.d.ts

@@ -1,85 +0,0 @@
-/**
- * Reverse-tunnel wire protocol (pure Bun, no third-party deps).
- *
- * A dev machine behind NAT cannot accept inbound connections, so the dev
- * `client` dials OUT to a public `relay` over a single control WebSocket. The
- * relay receives public HTTP requests and forwards each one down that socket;
- * the client replays it against the local app and sends the response back.
- *
- * Stage 1 covers HTTP request/response (webhooks). WebSocket passthrough for
- * telephony media streams is layered on later with additional message types.
- */
-/** Control-channel path the client connects to on the relay. */
-export declare const TUNNEL_CONTROL_PATH = "/__abs_tunnel/control";
-/** Header the relay strips/sets; lets the app know its public origin. */
-export declare const TUNNEL_FORWARDED_HOST_HEADER = "x-absolute-tunnel-host";
-/** A forwarded HTTP request (relay → client). Body is base64 (binary-safe). */
-export type TunnelRequestMessage = {
-    type: 'request';
-    id: string;
-    method: string;
-    /** Path + query, e.g. `/v1/sms/intake?x=1`. */
-    url: string;
-    headers: Record<string, string>;
-    bodyBase64?: string;
-};
-/** The client's response to a forwarded request (client → relay). */
-export type TunnelResponseMessage = {
-    type: 'response';
-    id: string;
-    status: number;
-    headers: Record<string, string>;
-    bodyBase64?: string;
-};
-/** Client could not produce a response (local app down, fetch threw). */
-export type TunnelErrorMessage = {
-    type: 'error';
-    id: string;
-    message: string;
-};
-/** Sent by the relay right after a successful auth handshake. */
-export type TunnelReadyMessage = {
-    type: 'ready';
-    /** Public base URL the relay is reachable at, e.g. `https://x.app`. */
-    publicUrl: string;
-};
-/** A public WS connection opened; client should dial the local app (relay → client). */
-export type TunnelWsOpenMessage = {
-    type: 'ws_open';
-    id: string;
-    /** Path + query of the upgraded request. */
-    url: string;
-    headers: Record<string, string>;
-};
-/** Result of the client opening the local WS (client → relay). */
-export type TunnelWsOpenAckMessage = {
-    type: 'ws_open_ack';
-    id: string;
-    ok: boolean;
-    error?: string;
-};
-/** One WS frame, either direction. Binary frames are base64. */
-export type TunnelWsDataMessage = {
-    type: 'ws_data';
-    id: string;
-    dataBase64: string;
-    binary: boolean;
-};
-/** A WS closed, either direction. */
-export type TunnelWsCloseMessage = {
-    type: 'ws_close';
-    id: string;
-    code?: number;
-    reason?: string;
-};
-/** App-level keepalive (either direction). */
-export type TunnelPingMessage = {
-    type: 'ping';
-};
-export type TunnelPongMessage = {
-    type: 'pong';
-};
-export type TunnelClientMessage = TunnelResponseMessage | TunnelErrorMessage | TunnelWsOpenAckMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPongMessage | TunnelPingMessage;
-export type TunnelServerMessage = TunnelRequestMessage | TunnelReadyMessage | TunnelWsOpenMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPingMessage | TunnelPongMessage;
-export declare const decodeTunnelMessage: (raw: string) => TunnelRequestMessage | TunnelResponseMessage | TunnelErrorMessage | TunnelReadyMessage | TunnelWsOpenMessage | TunnelWsOpenAckMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPingMessage | TunnelPongMessage | null;
-export declare const encodeTunnelMessage: (message: TunnelClientMessage | TunnelServerMessage) => string;

package/dist/src/dev/tunnel/relay.d.ts

@@ -1,28 +0,0 @@
-type RelayOptions = {
-    /** Port the relay listens on (App Platform injects PORT). */
-    port?: number;
-    /** Shared secret the dev client must present (?token=). */
-    token: string;
-    /** Public base URL the relay is reachable at. Falls back to the request
-     *  origin when omitted (App Platform: set APP_URL or pass explicitly). */
-    publicUrl?: string;
-    /** How long to wait for the dev client to answer a forwarded request. */
-    requestTimeoutMs?: number;
-};
-type ControlSocketData = {
-    control: true;
-};
-type PublicSocketData = {
-    control: false;
-    id: string;
-    url: string;
-    headers: Record<string, string>;
-};
-type SocketData = ControlSocketData | PublicSocketData;
-/**
- * Start the public reverse-tunnel relay. Holds one dev-client control socket
- * and forwards every other inbound HTTP request — and public WebSocket — down
- * it. Single-tenant: the shared `token` gates the control channel.
- */
-export declare const startTunnelRelay: (options: RelayOptions) => Bun.Server<SocketData>;
-export {};

package/dist/src/dev/webSocket.d.ts

@@ -1,9 +0,0 @@
-import type { HMRState } from './clientManager';
-import { type HMRWebSocket } from '../../types/websocket';
-export declare const broadcastToClients: (state: HMRState, message: {
-    type: string;
-    [key: string]: unknown;
-}) => void;
-export declare const handleClientConnect: (state: HMRState, client: HMRWebSocket, manifest: Record<string, string>) => void;
-export declare const handleClientDisconnect: (state: HMRState, client: HMRWebSocket) => void;
-export declare const handleHMRMessage: (state: HMRState, client: HMRWebSocket, message: unknown) => void;

package/dist/src/ember/browser.d.ts

@@ -1,24 +0,0 @@
-/**
- * Phase 1 Ember client entry.
- *
- * The page index file (emitted by the build) imports this module and
- * the user's compiled page module. We mount the page component into
- * `#ember-root` using the same `renderComponent` API SSR used — Ember
- * Router's hydration story is post-Phase-1 work; for v1 we re-render
- * client-side over the SSR'd HTML.
- *
- * `@ember/renderer` is loaded dynamically rather than via static import
- * because (a) the AbsoluteJS framework typecheck shouldn't require
- * ember-source as a dep, and (b) the resolved URL at runtime is
- * `/ember/vendor/ember_renderer.js` (the vendor build's output) rather
- * than the bare specifier — only the user's bundle pass knows which
- * mapping to apply.
- */
-declare global {
-    interface Window {
-        __INITIAL_PROPS__?: Record<string, unknown>;
-    }
-}
-export declare const mountEmberPage: (component: unknown, rootSelector?: string) => Promise<{
-    destroy?: () => void;
-}>;

package/dist/src/ember/index.d.ts

@@ -1,2 +0,0 @@
-export { handleEmberPageRequest, invalidateEmberSsrCache } from './pageHandler';
-export type { EmberPageRequestInput } from './pageHandler';

package/dist/src/ember/pageHandler.d.ts

@@ -1,35 +0,0 @@
-/**
- * Phase 1 Ember page handler.
- *
- * The compiled `pagePath` is a self-contained server bundle produced by
- * `compileEmber`. It exports `renderToHTML(props): string` — a one-call
- * entry that wires up simple-dom + the Glimmer renderer + the page
- * component, then returns serialized HTML. The handler's job is just:
- *
- *  1. Auto-inject `request.url` pathname into props as `url` (mirrors
- *     React/Svelte/Vue handlers — the convention all four adapters now
- *     share for native router cooperation).
- *  2. Polyfill `globalThis.Element` / `globalThis.Node` if missing. The
- *     Ember server bundle also installs the polyfill defensively, but
- *     installing here too means the polyfill is in place before the
- *     bundle's module body evaluates (any top-level Element refs).
- *  3. Dynamic-import the bundle, call `renderToHTML(props)`, wrap the
- *     result in a `<head>` + `<body>` shell with `__INITIAL_PROPS__`
- *     and the page index module load.
- *
- *  Phase 1 doesn't ship: streaming, slots, islands, HMR cache dirty,
- *  convention error rendering. Those layer on in phases 2 and 3.
- */
-export type EmberPageRequestInput = {
-    indexPath: string;
-    pagePath: string;
-    headTag?: `<head>${string}</head>`;
-    props?: Record<string, unknown>;
-    /** When provided, the request's pathname is auto-injected into props
-     *  as `url` (only if the caller didn't already pass one). Lets users
-     *  forward `request` straight from the Elysia handler instead of
-     *  unwrapping the URL by hand. */
-    request?: Request;
-};
-export declare const invalidateEmberSsrCache: () => void;
-export declare const handleEmberPageRequest: (input: EmberPageRequestInput) => Promise<Response>;

package/dist/src/ember/server.d.ts

@@ -1,2 +0,0 @@
-export { handleEmberPageRequest } from './pageHandler';
-export type { EmberPageRequestInput } from './pageHandler';

package/dist/src/index.d.ts

@@ -1,7 +0,0 @@
-import './angular/injectorPatch';
-export * from '../types';
-export * from './build/index';
-export * from './constants';
-export * from './core';
-export * from './plugins/index';
-export * from './utils/index';

package/dist/src/islands/browser.d.ts

@@ -1,3 +0,0 @@
-export { defineIslandRegistry } from '../core/islands';
-export { createIslandStore } from '../client/islandStore';
-export declare const renderIslandMarkup: () => Promise<never>;

package/dist/src/islands/index.d.ts

@@ -1,3 +0,0 @@
-export { defineIslandRegistry } from '../core/islands';
-export { renderIslandMarkup } from '../core/renderIslandMarkup';
-export { createIslandStore } from '../client/islandStore';

package/dist/src/islands/pageMetadata.d.ts

@@ -1,13 +0,0 @@
-import type { BuildConfig } from '../../types/build';
-import { type PageIslandUsage } from './sourceMetadata';
-export type PageIslandMetadata = {
-    islands: PageIslandUsage[];
-    pagePath: string;
-};
-declare global {
-    var __absolutePageIslandMetadata: Map<string, PageIslandMetadata> | undefined;
-}
-export declare const getCurrentPageIslandMetadata: () => Map<string, PageIslandMetadata>;
-export declare const getPagesUsingIslandSource: (sourcePath: string) => string[];
-export declare const loadPageIslandMetadata: (config: BuildConfig) => Promise<Map<string, PageIslandMetadata>>;
-export declare const setCurrentPageIslandMetadata: (metadata: Map<string, PageIslandMetadata>) => void;

package/dist/src/islands/sourceMetadata.d.ts

@@ -1,10 +0,0 @@
-import type { IslandFramework, IslandHydrate } from '../../types/island';
-export type PageIslandUsage = {
-    component: string;
-    framework: IslandFramework;
-    hydrate?: IslandHydrate;
-    source?: string;
-};
-export declare const buildIslandMetadataExports: (source: string) => string;
-export declare const extractIslandUsagesFromSource: (source: string) => PageIslandUsage[];
-export declare const hasIslandUsageInSource: (source: string) => boolean;