@absolutejs/absolute 0.19.0-beta.845 → 0.19.0-beta.846

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

@@ -1,16 +1,8 @@
-/** 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. */
+/** 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>;
-/** Post-process every .js in one or more vendor directories using the
- *  combined cross-framework path map. Required because each vendor build
- *  externalizes packages owned by other vendor pipelines (e.g. a dep-vendor
- *  wrapper around `@sentry/angular` externalizes `@angular/core` so it isn't
- *  duplicated, leaving a bare `from "@angular/core"` in the output). Without
- *  this rewrite the browser fetches the vendor file at runtime and chokes
- *  on the bare specifier. Run AFTER all vendor builds complete so every
- *  framework's path map is included in `vendorPaths`. */
 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/dev/angular/editTypeDetection.d.ts

@@ -0,0 +1,8 @@
+export type AngularEditType = 'template' | 'style-component' | 'class-component' | 'service-method-only' | 'service-with-side-effects' | 'route' | 'reboot';
+export type AngularEditClassification = {
+    type: AngularEditType;
+    reason: string;
+    sourceFile: string;
+};
+export declare const classifyAngularEdit: (file: string) => AngularEditClassification;
+export declare const collapseClassifications: (classifications: AngularEditClassification[]) => AngularEditClassification;

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

@@ -2,4 +2,7 @@ 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/utils/buildDirectoryLock.d.ts

@@ -1,5 +1,28 @@
+/** Lock file path: `<projectRoot>/.absolutejs/build.lock` where
+ *  projectRoot is `dirname(buildDirectory)`. Single file (NOT a dir
+ *  inside build/) — placing it inside .absolutejs avoids interfering
+ *  with watcher includes scoped to src/, db/, assets/, styles/. */
+export declare const lockPathForBuildDirectory: (buildDirectory: string) => string;
+/** Update the metadata in an already-acquired lock (e.g. fill in the
+ *  resolved dev-server port once it's been chosen). No-op if we don't
+ *  hold the lock for this build dir. */
+export declare const updateLockMetadata: (buildDirectory: string, updates: {
+    pid?: number;
+    port?: number | null;
+}) => void;
 export declare const acquireBuildDirectoryLock: (buildDirectory: string, options?: {
-    staleLockMs?: number;
-    timeoutMs?: number;
+    port?: number | null;
+    /** When true, an alive holder makes us wait (polling every
+     *  250ms up to `waitTimeoutMs`) instead of throwing immediately.
+     *  Default: true. Dev-server startup passes `wait: false` so
+     *  the user gets a fast Vite-style error pointing them at the
+     *  next free port. CLI build/compile leave it true so concurrent
+     *  invocations against a shared outdir serialize cleanly. */
+    wait?: boolean;
+    waitTimeoutMs?: number;
 }) => Promise<() => Promise<void>>;
-export declare const withBuildDirectoryLock: <T>(buildDirectory: string, action: () => Promise<T>) => Promise<T>;
+export declare const withBuildDirectoryLock: <T>(buildDirectory: string, action: () => Promise<T>, options?: {
+    port?: number | null;
+    wait?: boolean;
+    waitTimeoutMs?: number;
+}) => Promise<T>;

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

@@ -26,7 +26,12 @@ export declare const loadConfig: (configPath?: string) => Promise<{
     incrementalFiles?: string[];
     mode?: "production" | "development";
     dev?: {
+        port?: number;
+        portRange?: number;
+        strictPort?: boolean;
+        host?: string;
         https?: boolean;
+        watchDirs?: string[];
         devtools?: {
             projectRoot?: string;
             uuid?: string;

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

@@ -0,0 +1,21 @@
+/** Vite-style dev-server port resolution.
+ *
+ *  Probes the requested port. If busy, falls through to the next port up
+ *  to `portRange-1` neighbors. With `strictPort: true`, fails on the very
+ *  first conflict so users who pin a port know immediately.
+ *
+ *  Bun's `Bun.serve` rejects EADDRINUSE asynchronously and only after
+ *  partially binding, which is awkward to clean up — `node:net.createServer`
+ *  is simpler and battle-tested for this exact "is anyone listening here"
+ *  probe. */
+export type ResolveDevPortOptions = {
+    strictPort?: boolean;
+    portRange?: number;
+    host?: string;
+};
+export declare const isPortFree: (port: number, host?: string) => Promise<boolean>;
+export type ResolveDevPortResult = {
+    port: number;
+    fellBack: boolean;
+};
+export declare const resolveDevPort: (requestedPort: number, options?: ResolveDevPortOptions) => Promise<ResolveDevPortResult>;

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

@@ -0,0 +1,3 @@
+export declare const getNodeEnv: () => string | undefined;
+export declare const isProductionRuntime: () => boolean;
+export declare const isDevelopmentRuntime: () => boolean;

package/dist/svelte/index.js

@@ -2046,6 +2046,9 @@ var resolveAngularPackageDir = (specifier) => {
 };
 var init_resolveAngularPackage = () => {};
 
+// src/utils/runtimeMode.ts
+var ENV_VAR = "NODE_ENV", isProductionRuntime = () => process.env[ENV_VAR] === "production", isDevelopmentRuntime = () => process.env[ENV_VAR] === "development";
+
 // src/angular/angularPatch.ts
 var exports_angularPatch = {};
 __export(exports_angularPatch, {
@@ -2128,7 +2131,8 @@ var ensureHead = (doc) => {
   }
   layoutPatchApplied = true;
 }, applyPatches = async () => {
-  const { \u{275}DominoAdapter } = await import(resolveAngularRuntimePath("@angular/platform-server"));
+  const spec = isProductionRuntime() ? resolveAngularRuntimePath("@angular/platform-server") : "@angular/platform-server";
+  const { \u{275}DominoAdapter } = await import(spec);
   if (!\u{275}DominoAdapter?.prototype) {
     console.warn("[Angular Patch] \u0275DominoAdapter not found, skipping patches");
     return false;
@@ -2195,18 +2199,21 @@ var initDominoAdapter = (platformServer) => {
     console.error("Failed to initialize DominoAdapter:", err);
   }
 }, loadAngularDeps = async () => {
-  if (true) {
-    await import(resolveAngularRuntimePath("@angular/compiler"));
+  if (!isProductionRuntime()) {
+    await import("@angular/compiler");
   }
   const { applyPatches: applyPatches2 } = await Promise.resolve().then(() => (init_angularPatch(), exports_angularPatch));
   await applyPatches2();
+  const useBareSpecifiers = !isProductionRuntime();
   const [platformBrowser, platformServer, common, core] = await Promise.all([
-    import(resolveAngularRuntimePath("@angular/platform-browser")),
-    import(resolveAngularRuntimePath("@angular/platform-server")),
-    import(resolveAngularRuntimePath("@angular/common")),
-    import(resolveAngularRuntimePath("@angular/core"))
+    useBareSpecifiers ? import("@angular/platform-browser") : import(resolveAngularRuntimePath("@angular/platform-browser")),
+    useBareSpecifiers ? import("@angular/platform-server") : import(resolveAngularRuntimePath("@angular/platform-server")),
+    useBareSpecifiers ? import("@angular/common") : import(resolveAngularRuntimePath("@angular/common")),
+    useBareSpecifiers ? import("@angular/core") : import(resolveAngularRuntimePath("@angular/core"))
   ]);
-  if (false) {}
+  if (!isDevelopmentRuntime()) {
+    core.enableProdMode();
+  }
   initDominoAdapter(platformServer);
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
@@ -3765,5 +3772,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=B5BA84C66FADA6BA64756E2164756E21
+//# debugId=A6579D02DBD1FDED64756E2164756E21
 //# sourceMappingURL=index.js.map