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

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

@@ -754,6 +754,18 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     return runPostcss(await readFile(filePath, "utf-8"), filePath, config);
   }
   return compileStyleSource(filePath, undefined, undefined, config);
+}, CSS_IMPORT_PATTERN, resolveCssImportsSync = (content, baseDir, visited) => {
+  return content.replace(CSS_IMPORT_PATTERN, (match, importPath) => {
+    const fullPath = isAbsolute(importPath) ? importPath : resolve2(baseDir, importPath);
+    if (visited.has(fullPath))
+      return "";
+    if (!existsSync2(fullPath))
+      return match;
+    const nextVisited = new Set(visited);
+    nextVisited.add(fullPath);
+    const imported = readFileSync2(fullPath, "utf-8");
+    return resolveCssImportsSync(imported, dirname(fullPath), nextVisited);
+  });
 }, compileStyleFileIfNeededSync = (filePath, config) => {
   const rawContents = readFileSync2(filePath, "utf-8");
   const language = getStyleLanguage(filePath);
@@ -771,7 +783,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     }
     const contents = withAdditionalData(rawContents, options.additionalData);
     const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
-    return sass.compileString(contents, {
+    const compiled = sass.compileString(contents, {
       importers: [
         createSassImporter(filePath, loadPaths, language, config)
       ],
@@ -780,6 +792,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
       syntax: language === "sass" ? "indented" : "scss",
       url: new URL(`file://${filePath}`)
     }).css;
+    return resolveCssImportsSync(compiled, dirname(filePath), new Set([filePath]));
   }
   if (language === "less") {
     throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
@@ -787,7 +800,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (language === "stylus") {
     throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
   }
-  return rawContents;
+  return resolveCssImportsSync(rawContents, dirname(filePath), new Set([filePath]));
 }, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
 var init_stylePreprocessor = __esm(() => {
   CSS_EXTENSION_PATTERN = /\.css$/i;
@@ -800,6 +813,7 @@ var init_stylePreprocessor = __esm(() => {
   styleDependencyGraph = new Map;
   styleOutputHashes = new Map;
   stylePreprocessorPlugin = createStylePreprocessorPlugin();
+  CSS_IMPORT_PATTERN = /@import\s+["']([^"']+)["']\s*;?/g;
 });
 
 // src/core/svelteServerModule.ts
@@ -2046,6 +2060,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 +2145,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 +2213,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 +3786,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=B5BA84C66FADA6BA64756E2164756E21
+//# debugId=E4D8E2ADF4965B6964756E2164756E21
 //# sourceMappingURL=index.js.map