@absolutejs/absolute 0.20.0-beta.171 → 0.20.0-beta.173

package/dist/src/angular/components/defer-slot.component.d.ts

@@ -6,6 +6,7 @@ type DeferSlotResolver = () => Promise<AngularDeferSlotPayload>;
 type DeferSlotState = 'error' | 'fallback' | 'resolved';
 export declare class DeferSlotComponent implements AfterViewInit {
     private readonly cdr;
+    private readonly isServer;
     private readonly runtimeReady;
     private serverSlotRegistered;
     className?: string;

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

@@ -0,0 +1,8 @@
+import type { BunPlugin } from 'bun';
+/** Build error for a `react-router` import when the package isn't installed.
+ *  `fromAbsolute`: the import is the package's own (`react/router`). */
+export declare const missingReactRouterMessage: (specifier: string, importer: string, fromAbsolute: boolean) => string;
+export declare const isReactRouterMissing: (projectRoot: string) => boolean;
+/** Fails the build with `missingReactRouterMessage` on any `react-router`
+ *  import; null when react-router is installed (nothing to do). */
+export declare const createMissingReactRouterPlugin: (projectRoot: string, isMissing?: (projectRoot: string) => boolean) => BunPlugin | null;

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

@@ -1,7 +1,11 @@
-/** Mirror source paths under each compilation mode. Using the filesystem root
- * preserves relative imports, including imports outside the configured Vue
- * directory, without letting parent traversals escape the client/server tree.
- * Encode the root separately so Windows drives and UNC roots cannot collide. */
-export declare const vueModuleOutputPath: (outputDir: string, sourcePath: string) => string;
+export declare const vueModuleOutputPath: (outputDir: string, sourcePath: string, projectRoot?: string) => string;
+/** The specifier a compiled module at `importerSource` uses to import the
+ *  compiled `targetSource`. Inside one region this is the original relative
+ *  path; across regions it follows the generated layout instead. */
+export declare const vueRelativeOutputImport: (importerSource: string, targetSource: string, projectRoot?: string) => string;
+/** `specifier` as written in `importerSource`, which resolves to
+ *  `targetSource`, adjusted for the generated mirror: unchanged within one
+ *  region, re-derived from the generated layout across regions. */
+export declare const vueMirrorImport: (importerSource: string, specifier: string, targetSource: string, projectRoot?: string) => string;
 /** Reverse the generated mirror for composable hot-reload module identities. */
-export declare const vueModuleSourcePath: (outputDir: string, outputPath: string) => string | null;
+export declare const vueModuleSourcePath: (outputDir: string, outputPath: string, projectRoot?: string) => string | null;

package/dist/src/cli/scripts/bunCheck.d.ts

@@ -1,6 +1,8 @@
-export declare const BUN_CHECK_MIN_VERSION = "1.4.3";
+export declare const BUN_CHECK_MIN_VERSION = "1.4.4";
 /** Set to `tsc` to keep the TypeScript compiler as the checker. */
 export declare const CHECKER_ENV = "ABSOLUTE_TYPECHECK_CHECKER";
+/** Type-check, never a project's own `check` script in its place. */
+export declare const NO_SCRIPT = "--no-script";
 /** Caps the threads `bun check` starts: one per core by default, which a
  *  memory-capped container (Studio) cannot always afford. */
 export declare const THREADS_ENV = "ABSOLUTE_TYPECHECK_THREADS";

package/dist/src/cli/scripts/doctor.d.ts

@@ -1 +1,11 @@
+type CheckStatus = 'fail' | 'ok' | 'warn';
+/** The port the dev server would take, resolved the way `absolute dev` does:
+ *  ABSOLUTE_PORT, then PORT, then `dev.port` in the config, then the default. */
+export declare const devPort: (config: object | null, env?: Record<string, string | undefined>) => number;
+export declare const portCheck: (config: object | null, env?: Record<string, string | undefined>) => Promise<{
+    detail: string;
+    label: string;
+    status: CheckStatus;
+}>;
 export declare const runDoctor: (args: string[]) => Promise<void>;
+export {};

package/dist/src/core/streamingSlotWarningScope.d.ts

@@ -1,4 +1,7 @@
 export declare const captureStreamingSlotWarningCallsite: () => string | undefined;
 export declare const runWithStreamingSlotWarningScope: <T>(task: () => Promise<T> | T, metadata?: {
+    /** The handler turned collection off with `collectStreamingSlots: false`
+     *  (rather than leaving it at a framework default of off). */
+    explicitlyDisabled?: boolean;
     handlerCallsite?: string;
 }) => T | Promise<T>;

package/dist/src/dev/hot/reload.d.ts

@@ -18,3 +18,8 @@ export type ServerChangeOutcome = {
 export declare const reportEntryUpdate: (entryPath: string, elapsed: number) => void;
 /** Apply an edit to a server module. Edits apply one at a time. */
 export declare const applyServerChange: (path: string, entryPath: string) => Promise<ServerChangeOutcome>;
+/** Before the server entry re-runs for its own edit: apply every module it
+ *  imports whose file changed since it was loaded but whose edit never
+ *  arrived (a missed or misrouted watcher event). The entry re-runs next
+ *  and sees their new versions, so they do not re-run it themselves. */
+export declare const applyStaleModules: (entryPath: string) => Promise<void>;

package/dist/src/dev/hot/runtime.d.ts

@@ -93,6 +93,8 @@ export declare const setCurrent: (path: string, namespace: Record<string, unknow
 declare const forward: (target: Facade | undefined, initial: Record<string, unknown>, name: string, thisArg: unknown, args: unknown[], newTarget: unknown) => any;
 export declare const currentTag: (path: string) => number;
 export declare const managedModule: (path: string) => boolean;
+/** Every module the hot runtime has loaded. */
+export declare const managedModulePaths: () => string[];
 export declare const moduleRecord: (path: string) => ModuleRecord | undefined;
 export declare const nextTag: (path: string) => number;
 export declare const setAnalysis: (path: string, analysis: HotModuleAnalysis, source: string) => void;

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

@@ -1,4 +1,5 @@
-/** `@up/core/x.ts` → `../core/x.ts`, for resolving against the app folder. */
+/** `@up/core/x.ts` → `../core/x.ts`, for resolving against the app folder.
+ *  Percent-encoding the browser added (`%20` for a space) is decoded. */
 export declare const decodeSrcPath: (srcPath: string) => string;
 /** `../core/x.ts` → `@up/core/x.ts`; a path inside the app is unchanged. */
 export declare const encodeSrcPath: (relativePath: string) => string;

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

@@ -2,6 +2,11 @@ import type { ComponentType as ReactComponent } from 'react';
 import type { AbsoluteMobileBuildPageMetadata } from '../mobile/buildMetadata';
 import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
 type ReactPageRenderOptions = StreamingSlotEnhancerOptions & {
+    /** Collect `<SuspenseSlot>` / `<StreamSlot>` registrations during the
+     *  render and stream their resolved content after the shell. On by
+     *  default: a page that renders no slot gets byte-identical output and
+     *  no extra work. Set `false` to turn collection off for this route;
+     *  slots then stay on their fallback and a warning is logged once. */
     collectStreamingSlots?: boolean;
     /** Buffer this page's stream so it can carry a content-hash `ETag` and
      *  serve a `304` on repeat visits, at the cost of streaming's fast first

package/dist/src/react/router/Link.d.ts

@@ -29,7 +29,12 @@ export type LinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href' | '
  * `<Route>`s navigates client-side through react-router; anything else is
  * a real navigation to that page.
  *
- *   import { Link } from '@absolutejs/absolute/react/router';
+ *   import { Link } from '@absolutejs/absolute/react/components';
  *   <Link href="/pricing" prefetch="viewport">Pricing</Link>
+ *
+ * `@absolutejs/absolute/react/router` exports the same component next to
+ * `<UniversalRouter>`, so importing from it needs react-router installed;
+ * `react/components` doesn't. Without a `<UniversalRouter>`, a click falls
+ * through to the document, where `enableNavigation()` soft-navigates it.
  */
 export declare const Link: ({ href, prefetch: prefetchMode, prerender, replace, target, download, children, onBlur, onClick, onFocus, onPointerDown, onPointerEnter, onPointerLeave, ...rest }: LinkProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/react/serverComponents/pageHandler.d.ts

@@ -2,6 +2,8 @@ import { type StreamingSlotEnhancerOptions } from '../../core/responseEnhancers'
 export type ReactServerPageRequestInput<Props extends Record<string, unknown> = Record<never, never>> = StreamingSlotEnhancerOptions & {
     /** Buffer the response so it can carry a content-hash `ETag`. */
     bufferStreamForEtag?: boolean;
+    /** Collect streaming slots rendered by the page. On by default; set
+     *  `false` to turn it off (slots then keep their fallback). */
     collectStreamingSlots?: boolean;
     /** `asset(manifest, '<Page>RSC')`: the page's react-server bundle. */
     page: string;

package/dist/src/utils/portInUse.d.ts

@@ -0,0 +1,16 @@
+/** "Is something already listening on this TCP port?" — answered for every
+ *  address family a server can bind, not just the one a single probe
+ *  happens to use.
+ *
+ *  A lone bind probe misses real conflicts: on macOS/BSD a wildcard bind
+ *  (0.0.0.0) succeeds next to a listener on a specific address
+ *  (127.0.0.1), and an IPv4 bind says nothing about an IPv6-only listener.
+ *  So this first tries to connect to both loopbacks (catches any listener
+ *  that accepts local traffic), then tries to bind the IPv4 and IPv6
+ *  wildcards separately. Connects run before binds so a probe never
+ *  connects to its own listener, and every socket is closed before the
+ *  result is returned. */
+/** True when any process listens on `port` over IPv4, IPv6 or both. */
+export declare const isPortInUse: (port: number) => Promise<boolean>;
+/** Pids listening on `port`, best effort (lsof; empty where unavailable). */
+export declare const portListenerPids: (port: number) => number[];

package/dist/svelte/index.js

@@ -382,7 +382,7 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 });
 
 // src/utils/runtimeMode.ts
-var ENV_VAR = "NODE_ENV", getNodeEnv = () => process.env[ENV_VAR], isDevelopmentRuntime = () => process.env[ENV_VAR] === "development", isProductionRuntime = () => process.env[ENV_VAR] === "production";
+var ENV_VAR = "NODE_ENV", readEnv = () => typeof process === "undefined" ? undefined : process.env?.[ENV_VAR], getNodeEnv = () => readEnv(), isDevelopmentRuntime = () => readEnv() === "development", isProductionRuntime = () => readEnv() === "production";
 
 // src/build/stylePreprocessor.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
@@ -1390,13 +1390,25 @@ var ISLAND_MARKER = 'data-island="true"', MANIFEST_MARKER = "__ABSOLUTE_MANIFEST
     return;
   warnedMissingBootstrap = true;
   logWarn("A page contains islands, but the build manifest has no islands bootstrap, so they will render without hydrating. Set `islands.registry` in absolute.config.ts (a default bootstrap is generated from it) or point `islands.bootstrap` at a file that calls startIslands().");
-}, manifestBuildDir, WINDOWS_ABSOLUTE_PATH, isServerFilePath = (value) => {
+}, MANIFEST_BUILD_DIR_KEY, getManifestBuildDir = () => {
+  const value = Reflect.get(globalThis, MANIFEST_BUILD_DIR_KEY);
+  return typeof value === "string" ? value : undefined;
+}, WINDOWS_ABSOLUTE_PATH, withTrailingSlash = (path) => path.endsWith("/") ? path : `${path}/`, currentWorkingRoot = () => {
+  try {
+    return withTrailingSlash(process.cwd().replaceAll("\\", "/"));
+  } catch {
+    return;
+  }
+}, isServerFilePath = (value) => {
   if (WINDOWS_ABSOLUTE_PATH.test(value))
     return true;
-  if (!manifestBuildDir)
-    return false;
-  const root = manifestBuildDir.endsWith("/") ? manifestBuildDir : `${manifestBuildDir}/`;
-  return value.startsWith(root);
+  const buildDir = getManifestBuildDir();
+  if (buildDir && value.startsWith(withTrailingSlash(buildDir)))
+    return true;
+  const root = currentWorkingRoot();
+  if (root && root !== "/" && value.startsWith(root))
+    return true;
+  return false;
 }, toBrowserManifest = (manifest) => {
   const browserManifest = {};
   for (const [key, value] of Object.entries(manifest)) {
@@ -1608,12 +1620,13 @@ var ISLAND_MARKER = 'data-island="true"', MANIFEST_MARKER = "__ABSOLUTE_MANIFEST
   return pipeStreamWithIslandMarkerDetection(stream, markup, () => warnIfBootstrapMissing(manifest));
 }, setCurrentIslandManifest = (manifest, buildDir) => {
   globalThis.__absoluteManifest = manifest;
-  manifestBuildDir = buildDir?.replaceAll("\\", "/");
+  Reflect.set(globalThis, MANIFEST_BUILD_DIR_KEY, buildDir?.replaceAll("\\", "/"));
 };
 var init_islandPageContext = __esm(() => {
   init_escapeScriptContent();
   init_cspNonceRef();
   init_logger();
+  MANIFEST_BUILD_DIR_KEY = Symbol.for("absolutejs.islandManifestBuildDir");
   WINDOWS_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]|^\\\\/;
 });
 
@@ -5090,7 +5103,7 @@ var setStreamingSlotWarningController = (controller) => {
   Reflect.set(globalThis, STREAMING_SLOT_WARNING_STORAGE_KEY, controller);
 };
 var warnMissingStreamingSlotCollector = (primitiveName) => {
-  if (isProductionRuntime() || isStreamingSlotCollectionActive()) {
+  if (isStreamingSlotCollectionActive()) {
     return;
   }
   getWarningController()?.maybeWarn(primitiveName);
@@ -5277,7 +5290,11 @@ var extractCallsiteFromStack = (stack) => {
 `).slice(1).map((line) => line.trim()).filter((frame) => !shouldIgnoreWarningFrame(frame)).map((frame) => getWarningLocation(frame)).find((frameLocation) => frameLocation !== undefined);
   return location ? normalizeCallsitePath2(location) : undefined;
 };
-var buildMissingCollectorWarning = (primitiveName, handlerCallsite) => `${primitiveName} rendered during SSR without streaming slot collection enabled. Add { collectStreamingSlots: true } to this page handler to enable out-of-order streaming for this route.${handlerCallsite ? ` Update ${formatWarningCallsite(handlerCallsite)}.` : ""}`;
+var buildMissingCollectorWarning = (primitiveName, { explicitlyDisabled, handlerCallsite }) => {
+  const fix = explicitlyDisabled ? "This page handler sets { collectStreamingSlots: false }, so the slot stays on its fallback and never streams. Remove the option (or set it to true) to stream this route." : "The slot stays on its fallback and never streams. Add { collectStreamingSlots: true } to this page handler to enable out-of-order streaming for this route.";
+  return `${primitiveName} rendered during SSR without streaming slot collection enabled. ${fix}${handlerCallsite ? ` Update ${formatWarningCallsite(handlerCallsite)}.` : ""}`;
+};
+var productionWarnings = new Set;
 setStreamingSlotWarningController({
   maybeWarn: (primitiveName) => {
     const store = getWarningStorage()?.getStore();
@@ -5285,7 +5302,13 @@ setStreamingSlotWarningController({
       return;
     }
     store.hasWarned = true;
-    logWarn(buildMissingCollectorWarning(primitiveName, store.handlerCallsite));
+    const message = buildMissingCollectorWarning(primitiveName, store);
+    if (isProductionRuntime()) {
+      if (productionWarnings.has(message))
+        return;
+      productionWarnings.add(message);
+    }
+    logWarn(message);
   }
 });
 var captureStreamingSlotWarningCallsite = () => {
@@ -5298,7 +5321,11 @@ var captureStreamingSlotWarningCallsite = () => {
   }
   return extractCallsiteFromStack(stack);
 };
-var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage().run({ handlerCallsite: metadata?.handlerCallsite, hasWarned: false }, task);
+var runWithStreamingSlotWarningScope = (task, metadata) => ensureWarningStorage().run({
+  explicitlyDisabled: metadata?.explicitlyDisabled === true,
+  handlerCallsite: metadata?.handlerCallsite,
+  hasWarned: false
+}, task);
 
 // src/svelte/pageHandler.ts
 init_routeAssets();
@@ -6074,5 +6101,5 @@ export {
   useIslandStore
 };
 
-//# debugId=55A3DA350585CD1864756E2164756E21
+//# debugId=B0580FC0A61D8A6F64756E2164756E21
 //# sourceMappingURL=index.js.map