@asheeui/next 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ashee Softworks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,290 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let _asheeui_utils_node = require("@asheeui/utils/node");
+//#region src/generate.ts
+/**
+* The import specifier used across AsheeUI for the config module.
+*
+* @example
+* ```ts
+* import config from "virtual:ashee-config";
+* ```
+*/
+const VIRTUAL_ID = "virtual:ashee-config";
+/**
+* Location of the generated shim, relative to the project root.
+*
+* Deliberately kept outside `node_modules`: package managers and CI
+* treat `node_modules` as fully disposable, and a shim the dev server
+* depends on should not live somewhere that can vanish out from under
+* it.
+*/
+const SHIM_RELATIVE_PATH = ".ashee/generated-config.mjs";
+/**
+* Resolve the absolute path of the generated shim for a project root.
+*
+* @param root - Project root directory. Defaults to `process.cwd()`.
+* @returns Absolute path of the shim file.
+*/
+function resolveShimPath(root) {
+	return (0, node_path.resolve)(root ?? process.cwd(), SHIM_RELATIVE_PATH);
+}
+/**
+* Resolve every candidate config filename to an absolute path under
+* `root`, whether or not the files currently exist.
+*
+* These paths are registered as webpack "missing dependencies" so that
+* creating a config file for the first time triggers a rebuild.
+*
+* @param root - Project root directory. Defaults to `process.cwd()`.
+* @returns Absolute paths for every known config filename.
+*/
+function resolveCandidatePaths(root) {
+	const base = root ?? process.cwd();
+	return _asheeui_utils_node.CANDIDATES.map((file) => (0, node_path.resolve)(base, file));
+}
+/**
+* Build an import specifier for `toFile` relative to `fromFile`'s directory.
+*
+* Turbopack rejects absolute ("server-relative") import specifiers, so the
+* shim must reference the discovered config with a path relative to itself.
+*
+* @param fromFile - Absolute path of the importing file.
+* @param toFile - Absolute path of the imported file.
+* @returns A `./`-prefixed relative specifier.
+*/
+function toRelativeSpecifier(fromFile, toFile) {
+	const rel = (0, node_path.relative)((0, node_path.dirname)(fromFile), toFile).replaceAll("\\", "/");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+/**
+* Regenerate the config shim, mirroring `@asheeui/vite`'s virtual module:
+* if a config file exists we re-export its default export, otherwise we
+* export `undefined`.
+*
+* The write is skipped when the content is unchanged, so webpack's
+* `beforeCompile` hook does not churn the file (or Turbopack's watcher)
+* on every rebuild.
+*
+* @param root - Project root directory. Defaults to `process.cwd()`.
+* @returns The absolute path of the regenerated shim file.
+*/
+function generateShim(root) {
+	const shimPath = resolveShimPath(root);
+	const configPath = (0, _asheeui_utils_node.discoverConfig)(root);
+	const content = configPath ? `export { default } from ${JSON.stringify(toRelativeSpecifier(shimPath, configPath))};\n` : "export default undefined;\n";
+	if (!(0, node_fs.existsSync)(shimPath) || (0, node_fs.readFileSync)(shimPath, "utf8") !== content) {
+		(0, node_fs.mkdirSync)((0, node_path.dirname)(shimPath), { recursive: true });
+		(0, node_fs.writeFileSync)(shimPath, content, "utf8");
+	}
+	return shimPath;
+}
+//#endregion
+//#region src/turbopack.ts
+/**
+* Point `virtual:ashee-config` at the generated shim inside a Turbopack
+* config section.
+*
+* The given `target` object is mutated and then returned so the caller
+* can use it in an inline expression.
+*
+* @param target - Turbopack config section (stable or experimental).
+* @param shimPath - Project-root-relative path of the generated shim.
+* @returns The same `target` object, with the alias registered.
+*
+* @example
+* ```ts
+* const turbopack = addAsheeConfigResolveAlias(
+*   { resolveAlias: {} },
+*   "./.ashee/generated-config.mjs",
+* );
+* ```
+*/
+function addAsheeConfigResolveAlias(target, shimPath) {
+	target.resolveAlias ??= {};
+	target.resolveAlias[VIRTUAL_ID] = shimPath;
+	return target;
+}
+//#endregion
+//#region src/webpack.ts
+/**
+* Exact-match alias key (`$`-suffixed) so a hypothetical future
+* `virtual:ashee-config/foo` import does not also resolve through this
+* alias.
+*/
+const EXACT_VIRTUAL_ID = `${VIRTUAL_ID}$`;
+/**
+* Point `virtual:ashee-config` at the generated shim so app code keeps
+* using the same import specifier as Vite.
+*
+* @param config - Webpack config section to patch (mutated in place).
+* @param shimPath - Absolute path of the generated shim.
+* @returns The same `config` object, with the alias registered.
+*
+* @example
+* ```ts
+* const config = addAsheeConfigAlias(
+*   { resolve: { alias: {} } },
+*   "/proj/.ashee/generated-config.mjs",
+* );
+* ```
+*/
+function addAsheeConfigAlias(config, shimPath) {
+	config.resolve ??= {};
+	config.resolve.alias ??= {};
+	config.resolve.alias[EXACT_VIRTUAL_ID] = shimPath;
+	return config;
+}
+/**
+* Create a dev-only webpack plugin that regenerates the shim before
+* every compile so edits to an existing config file are always picked
+* up.
+*
+* The plugin also registers every candidate filename as a webpack
+* "missing dependency": the shim has no reference to a file that does
+* not exist yet, so without this, *creating* the config file for the
+* first time would never trigger a rebuild on its own. Writes are
+* skipped when content is unchanged, keeping rebuilds cheap.
+*
+* @param regenerate - Callback that rewrites the shim file.
+* @param candidatePaths - Absolute candidate config paths to watch as
+*   missing dependencies.
+* @returns A webpack plugin object.
+*/
+function createBeforeCompilePlugin(regenerate, candidatePaths) {
+	return { apply(compiler) {
+		compiler.hooks.beforeCompile.tap("ashee:virtual-config", () => {
+			regenerate();
+		});
+		compiler.hooks.afterCompile.tap("ashee:virtual-config", (compilation) => {
+			for (const path of candidatePaths) compilation.missingDependencies.add(path);
+		});
+	} };
+}
+/**
+* Create the webpack hook that Next invokes when building.
+*
+* The returned hook always adds the config alias; in dev mode it also
+* installs the `beforeCompile` regeneration plugin and the
+* missing-dependency watcher.
+*
+* @param options - Hook options.
+* @param options.shimPath - Absolute path of the generated shim.
+* @param options.candidatePaths - Absolute candidate config paths.
+* @param options.root - Project root used when regenerating the shim.
+* @param options.regenerate - Function that regenerates the shim for a
+*   given root directory.
+* @returns A webpack config hook matching Next's `webpack` signature.
+*/
+function createWebpackHook(options) {
+	const { shimPath, candidatePaths, regenerate, root } = options;
+	return (config, context) => {
+		addAsheeConfigAlias(config, shimPath);
+		if (context.dev) {
+			config.plugins ??= [];
+			config.plugins.push(createBeforeCompilePlugin(() => regenerate(root), candidatePaths));
+		}
+		return config;
+	};
+}
+//#endregion
+//#region src/with-ashee-ui.ts
+/**
+* AsheeUI packages that ship TypeScript source and must be compiled by
+* Next.
+*
+* `transpilePackages` takes npm package names, deduped against any the
+* consumer provides.
+*/
+const ASHEE_TRANSPILE_PACKAGES = ["asheeui"];
+/**
+* Wrap a `next.config.mjs`/`next.config.ts` object with AsheeUI
+* integration.
+*
+* The wrapper:
+* 1. Generates a config shim at `.ashee/generated-config.mjs` (same
+*    resolution as `@asheeui/vite`'s `virtual:ashee-config`).
+* 2. Adds a `virtual:ashee-config` alias for Webpack and Turbopack so
+*    app code uses the identical import specifier in both bundlers.
+*    Webpack gets an absolute path (it resolves against its own
+*    context, not the `root` override), Turbopack gets a
+*    project-root-relative one (it rejects absolute targets).
+* 3. Merges `transpilePackages` so AsheeUI's source-shipping packages
+*    are compiled by Next.
+*
+* @param config - Next config to wrap. AsheeUI override keys (`root`,
+*   `transpilePackages`) are consumed and stripped from the returned
+*   `NextConfig`. Defaults to `{}`.
+* @returns A plain `NextConfig` with the AsheeUI integration applied.
+*
+* @example
+* ```ts
+* // next.config.ts
+* import { withAsheeUI } from "@asheeui/next";
+*
+* export default withAsheeUI({
+*   transpilePackages: ["@my-org/ui"],
+* });
+* ```
+*/
+function withAsheeUI(config = {}) {
+	const { root, transpilePackages: extraTranspilePackages, ...nextConfig } = config;
+	const baseDir = root ?? process.cwd();
+	const legacyConfig = nextConfig;
+	generateShim(baseDir);
+	const absoluteShimPath = resolveShimPath(baseDir);
+	const relativeShimPath = `./${SHIM_RELATIVE_PATH}`;
+	const candidatePaths = resolveCandidatePaths(baseDir);
+	const transpilePackages = [.../* @__PURE__ */ new Set([
+		...ASHEE_TRANSPILE_PACKAGES,
+		...legacyConfig.transpilePackages ?? [],
+		...extraTranspilePackages ?? []
+	])];
+	const userWebpack = nextConfig.webpack;
+	const webpack = ((config, context) => {
+		const patchConfig = config;
+		const patchContext = context;
+		const hook = createWebpackHook({
+			shimPath: absoluteShimPath,
+			candidatePaths,
+			root: baseDir,
+			regenerate: generateShim
+		});
+		if (userWebpack) return hook(userWebpack(patchConfig, patchContext), patchContext);
+		return hook(patchConfig, patchContext);
+	});
+	const turbopackResolveAlias = {
+		...nextConfig.turbopack?.resolveAlias ?? {},
+		[VIRTUAL_ID]: relativeShimPath
+	};
+	const turbopack = {
+		...nextConfig.turbopack,
+		resolveAlias: turbopackResolveAlias
+	};
+	const patchedConfig = {
+		...nextConfig,
+		transpilePackages,
+		webpack,
+		turbopack
+	};
+	if (legacyConfig.experimental?.turbo) {
+		const turboPatch = addAsheeConfigResolveAlias(legacyConfig.experimental.turbo, relativeShimPath);
+		patchedConfig.experimental = {
+			...nextConfig.experimental,
+			turbo: turboPatch
+		};
+	}
+	return patchedConfig;
+}
+//#endregion
+exports.SHIM_RELATIVE_PATH = SHIM_RELATIVE_PATH;
+exports.VIRTUAL_ID = VIRTUAL_ID;
+exports.addAsheeConfigAlias = addAsheeConfigAlias;
+exports.addAsheeConfigResolveAlias = addAsheeConfigResolveAlias;
+exports.createBeforeCompilePlugin = createBeforeCompilePlugin;
+exports.createWebpackHook = createWebpackHook;
+exports.generateShim = generateShim;
+exports.resolveCandidatePaths = resolveCandidatePaths;
+exports.resolveShimPath = resolveShimPath;
+exports.withAsheeUI = withAsheeUI;

package/dist/index.d.cts

@@ -0,0 +1,256 @@
+import { NextConfig } from "next";
+//#region src/generate.d.ts
+/**
+ * The import specifier used across AsheeUI for the config module.
+ *
+ * @example
+ * ```ts
+ * import config from "virtual:ashee-config";
+ * ```
+ */
+declare const VIRTUAL_ID = "virtual:ashee-config";
+/**
+ * Location of the generated shim, relative to the project root.
+ *
+ * Deliberately kept outside `node_modules`: package managers and CI
+ * treat `node_modules` as fully disposable, and a shim the dev server
+ * depends on should not live somewhere that can vanish out from under
+ * it.
+ */
+declare const SHIM_RELATIVE_PATH = ".ashee/generated-config.mjs";
+/**
+ * Resolve the absolute path of the generated shim for a project root.
+ *
+ * @param root - Project root directory. Defaults to `process.cwd()`.
+ * @returns Absolute path of the shim file.
+ */
+declare function resolveShimPath(root?: string): string;
+/**
+ * Resolve every candidate config filename to an absolute path under
+ * `root`, whether or not the files currently exist.
+ *
+ * These paths are registered as webpack "missing dependencies" so that
+ * creating a config file for the first time triggers a rebuild.
+ *
+ * @param root - Project root directory. Defaults to `process.cwd()`.
+ * @returns Absolute paths for every known config filename.
+ */
+declare function resolveCandidatePaths(root?: string): string[];
+/**
+ * Regenerate the config shim, mirroring `@asheeui/vite`'s virtual module:
+ * if a config file exists we re-export its default export, otherwise we
+ * export `undefined`.
+ *
+ * The write is skipped when the content is unchanged, so webpack's
+ * `beforeCompile` hook does not churn the file (or Turbopack's watcher)
+ * on every rebuild.
+ *
+ * @param root - Project root directory. Defaults to `process.cwd()`.
+ * @returns The absolute path of the regenerated shim file.
+ */
+declare function generateShim(root?: string): string;
+//#endregion
+//#region src/turbopack.d.ts
+/**
+ * The part of Next's Turbopack config that this package patches.
+ *
+ * Next exposes the same shape both at the stable `turbopack` key
+ * (`>= 15.1`) and at the deprecated `experimental.turbo` key, so one
+ * structural type covers both merge targets.
+ */
+interface TurbopackPatch {
+  /** Alias map used to redirect module specifiers during resolution. */
+  resolveAlias?: Record<string, string>;
+}
+/**
+ * Point `virtual:ashee-config` at the generated shim inside a Turbopack
+ * config section.
+ *
+ * The given `target` object is mutated and then returned so the caller
+ * can use it in an inline expression.
+ *
+ * @param target - Turbopack config section (stable or experimental).
+ * @param shimPath - Project-root-relative path of the generated shim.
+ * @returns The same `target` object, with the alias registered.
+ *
+ * @example
+ * ```ts
+ * const turbopack = addAsheeConfigResolveAlias(
+ *   { resolveAlias: {} },
+ *   "./.ashee/generated-config.mjs",
+ * );
+ * ```
+ */
+declare function addAsheeConfigResolveAlias(target: TurbopackPatch, shimPath: string): TurbopackPatch;
+//#endregion
+//#region src/types.d.ts
+/**
+ * AsheeUI-specific overrides that can be spread into a `NextConfig`
+ * when calling {@link withAsheeUI}.
+ */
+interface AsheeUIConfigOverrides {
+  /**
+   * Override the directory to look for `asheeui.config.*` in.
+   *
+   * Defaults to the project root (the directory containing
+   * `next.config.*`).
+   */
+  root?: string;
+  /**
+   * Extra packages appended to `transpilePackages`, deduped against the
+   * built-in AsheeUI package list.
+   */
+  transpilePackages?: string[];
+}
+/**
+ * The config object accepted by `withAsheeUI`: a standard `NextConfig`
+ * merged with AsheeUI overrides.
+ */
+type WithAsheeUIConfig = NextConfig & AsheeUIConfigOverrides;
+/**
+ * Structural view of the webpack config sections that AsheeUI patches.
+ *
+ * Kept deliberately minimal so this package does not need a webpack
+ * type dependency.
+ */
+interface WebpackConfigPatch {
+  /** Webpack resolution options. */
+  resolve?: {
+    /** Module alias map. */
+    alias?: Record<string, string>;
+  };
+  /** Webpack plugins to append to. */
+  plugins?: WebpackPluginLike[];
+}
+/**
+ * Structural view of the compilation object passed to webpack's
+ * `afterCompile` hook.
+ */
+interface WebpackCompilationLike {
+  /** Collector for files webpack should watch even when missing. */
+  missingDependencies: {
+    add: (path: string) => void;
+  };
+}
+/**
+ * Minimal structural view of a webpack plugin used by this package.
+ *
+ * Only the `apply` method and the `beforeCompile`/`afterCompile` hooks
+ * are modelled.
+ */
+interface WebpackPluginLike {
+  /** Install the plugin onto the compiler. */
+  apply: (compiler: {
+    hooks: {
+      /** Fired before each compilation begins. */
+      beforeCompile: {
+        tap: (name: string, callback: () => void) => void;
+      };
+      /** Fired after each compilation finishes. */
+      afterCompile: {
+        tap: (name: string, callback: (compilation: WebpackCompilationLike) => void) => void;
+      };
+    };
+  }) => void;
+}
+/**
+ * Minimal structural view of the webpack context object passed to the
+ * `webpack` config function by Next.
+ */
+interface WebpackContextLike {
+  /** `true` when Next is running a development build. */
+  dev: boolean;
+}
+//#endregion
+//#region src/webpack.d.ts
+/**
+ * Point `virtual:ashee-config` at the generated shim so app code keeps
+ * using the same import specifier as Vite.
+ *
+ * @param config - Webpack config section to patch (mutated in place).
+ * @param shimPath - Absolute path of the generated shim.
+ * @returns The same `config` object, with the alias registered.
+ *
+ * @example
+ * ```ts
+ * const config = addAsheeConfigAlias(
+ *   { resolve: { alias: {} } },
+ *   "/proj/.ashee/generated-config.mjs",
+ * );
+ * ```
+ */
+declare function addAsheeConfigAlias(config: WebpackConfigPatch, shimPath: string): WebpackConfigPatch;
+/**
+ * Create a dev-only webpack plugin that regenerates the shim before
+ * every compile so edits to an existing config file are always picked
+ * up.
+ *
+ * The plugin also registers every candidate filename as a webpack
+ * "missing dependency": the shim has no reference to a file that does
+ * not exist yet, so without this, *creating* the config file for the
+ * first time would never trigger a rebuild on its own. Writes are
+ * skipped when content is unchanged, keeping rebuilds cheap.
+ *
+ * @param regenerate - Callback that rewrites the shim file.
+ * @param candidatePaths - Absolute candidate config paths to watch as
+ *   missing dependencies.
+ * @returns A webpack plugin object.
+ */
+declare function createBeforeCompilePlugin(regenerate: () => void, candidatePaths: string[]): WebpackPluginLike;
+/**
+ * Create the webpack hook that Next invokes when building.
+ *
+ * The returned hook always adds the config alias; in dev mode it also
+ * installs the `beforeCompile` regeneration plugin and the
+ * missing-dependency watcher.
+ *
+ * @param options - Hook options.
+ * @param options.shimPath - Absolute path of the generated shim.
+ * @param options.candidatePaths - Absolute candidate config paths.
+ * @param options.root - Project root used when regenerating the shim.
+ * @param options.regenerate - Function that regenerates the shim for a
+ *   given root directory.
+ * @returns A webpack config hook matching Next's `webpack` signature.
+ */
+declare function createWebpackHook(options: {
+  shimPath: string;
+  candidatePaths: string[];
+  root?: string;
+  regenerate: (root?: string) => string;
+}): (config: WebpackConfigPatch, context: WebpackContextLike) => WebpackConfigPatch;
+//#endregion
+//#region src/with-ashee-ui.d.ts
+/**
+ * Wrap a `next.config.mjs`/`next.config.ts` object with AsheeUI
+ * integration.
+ *
+ * The wrapper:
+ * 1. Generates a config shim at `.ashee/generated-config.mjs` (same
+ *    resolution as `@asheeui/vite`'s `virtual:ashee-config`).
+ * 2. Adds a `virtual:ashee-config` alias for Webpack and Turbopack so
+ *    app code uses the identical import specifier in both bundlers.
+ *    Webpack gets an absolute path (it resolves against its own
+ *    context, not the `root` override), Turbopack gets a
+ *    project-root-relative one (it rejects absolute targets).
+ * 3. Merges `transpilePackages` so AsheeUI's source-shipping packages
+ *    are compiled by Next.
+ *
+ * @param config - Next config to wrap. AsheeUI override keys (`root`,
+ *   `transpilePackages`) are consumed and stripped from the returned
+ *   `NextConfig`. Defaults to `{}`.
+ * @returns A plain `NextConfig` with the AsheeUI integration applied.
+ *
+ * @example
+ * ```ts
+ * // next.config.ts
+ * import { withAsheeUI } from "@asheeui/next";
+ *
+ * export default withAsheeUI({
+ *   transpilePackages: ["@my-org/ui"],
+ * });
+ * ```
+ */
+declare function withAsheeUI(config?: WithAsheeUIConfig): NextConfig;
+//#endregion
+export { AsheeUIConfigOverrides, SHIM_RELATIVE_PATH, TurbopackPatch, VIRTUAL_ID, WebpackCompilationLike, WebpackConfigPatch, WebpackContextLike, WebpackPluginLike, WithAsheeUIConfig, addAsheeConfigAlias, addAsheeConfigResolveAlias, createBeforeCompilePlugin, createWebpackHook, generateShim, resolveCandidatePaths, resolveShimPath, withAsheeUI };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/generate.ts","../src/turbopack.ts","../src/types.ts","../src/webpack.ts","../src/with-ashee-ui.ts"],"mappings":";;;;;;;;;;cAYa;;;;;;;;;cAUA;;;;;;;iBAQG,gBAAgB;;;;;;;;;;;iBAchB,sBAAsB;;;;;;;;;;;;;iBAgCtB,aAAa;;;;;;;;;;UCnEZ;;EAEf,eAAe;;;;;;;;;;;;;;;;;;;;;iBAsBD,2BACd,QAAQ,gBACR,mBACC;;;;;;;UC9Bc;;;;;;;EAOf;;;;;EAKA;;;;;;KAOU,oBAAoB,aAAa;;;;;;;UAQ5B;;EAEf;;IAEE,QAAQ;;;EAGV,UAAU;;;;;;UAOK;;EAEf;IAAuB,MAAM;;;;;;;;;UASd;;EAEf,QAAQ;IACN;;MAEE;QACE,MAAM,cAAc;;;MAGtB;QACE,MACE,cACA,WAAW,aAAa;;;;;;;;;UAWjB;;EAEf;;;;;;;;;;;;;;;;;;;;iBCrDc,oBACd,QAAQ,oBACR,mBACC;;;;;;;;;;;;;;;;;iBAuBa,0BACd,wBACA,2BACC;;;;;;;;;;;;;;;;iBA8Ba,kBAAkB;EAChC;EACA;EACA;EACA,aAAa;KAEb,QAAQ,oBACR,SAAS,uBACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCxBW,YAAY,SAAQ,oBAAyB"}

package/dist/index.d.mts

@@ -0,0 +1,256 @@
+import { NextConfig } from "next";
+//#region src/generate.d.ts
+/**
+ * The import specifier used across AsheeUI for the config module.
+ *
+ * @example
+ * ```ts
+ * import config from "virtual:ashee-config";
+ * ```
+ */
+declare const VIRTUAL_ID = "virtual:ashee-config";
+/**
+ * Location of the generated shim, relative to the project root.
+ *
+ * Deliberately kept outside `node_modules`: package managers and CI
+ * treat `node_modules` as fully disposable, and a shim the dev server
+ * depends on should not live somewhere that can vanish out from under
+ * it.
+ */
+declare const SHIM_RELATIVE_PATH = ".ashee/generated-config.mjs";
+/**
+ * Resolve the absolute path of the generated shim for a project root.
+ *
+ * @param root - Project root directory. Defaults to `process.cwd()`.
+ * @returns Absolute path of the shim file.
+ */
+declare function resolveShimPath(root?: string): string;
+/**
+ * Resolve every candidate config filename to an absolute path under
+ * `root`, whether or not the files currently exist.
+ *
+ * These paths are registered as webpack "missing dependencies" so that
+ * creating a config file for the first time triggers a rebuild.
+ *
+ * @param root - Project root directory. Defaults to `process.cwd()`.
+ * @returns Absolute paths for every known config filename.
+ */
+declare function resolveCandidatePaths(root?: string): string[];
+/**
+ * Regenerate the config shim, mirroring `@asheeui/vite`'s virtual module:
+ * if a config file exists we re-export its default export, otherwise we
+ * export `undefined`.
+ *
+ * The write is skipped when the content is unchanged, so webpack's
+ * `beforeCompile` hook does not churn the file (or Turbopack's watcher)
+ * on every rebuild.
+ *
+ * @param root - Project root directory. Defaults to `process.cwd()`.
+ * @returns The absolute path of the regenerated shim file.
+ */
+declare function generateShim(root?: string): string;
+//#endregion
+//#region src/turbopack.d.ts
+/**
+ * The part of Next's Turbopack config that this package patches.
+ *
+ * Next exposes the same shape both at the stable `turbopack` key
+ * (`>= 15.1`) and at the deprecated `experimental.turbo` key, so one
+ * structural type covers both merge targets.
+ */
+interface TurbopackPatch {
+  /** Alias map used to redirect module specifiers during resolution. */
+  resolveAlias?: Record<string, string>;
+}
+/**
+ * Point `virtual:ashee-config` at the generated shim inside a Turbopack
+ * config section.
+ *
+ * The given `target` object is mutated and then returned so the caller
+ * can use it in an inline expression.
+ *
+ * @param target - Turbopack config section (stable or experimental).
+ * @param shimPath - Project-root-relative path of the generated shim.
+ * @returns The same `target` object, with the alias registered.
+ *
+ * @example
+ * ```ts
+ * const turbopack = addAsheeConfigResolveAlias(
+ *   { resolveAlias: {} },
+ *   "./.ashee/generated-config.mjs",
+ * );
+ * ```
+ */
+declare function addAsheeConfigResolveAlias(target: TurbopackPatch, shimPath: string): TurbopackPatch;
+//#endregion
+//#region src/types.d.ts
+/**
+ * AsheeUI-specific overrides that can be spread into a `NextConfig`
+ * when calling {@link withAsheeUI}.
+ */
+interface AsheeUIConfigOverrides {
+  /**
+   * Override the directory to look for `asheeui.config.*` in.
+   *
+   * Defaults to the project root (the directory containing
+   * `next.config.*`).
+   */
+  root?: string;
+  /**
+   * Extra packages appended to `transpilePackages`, deduped against the
+   * built-in AsheeUI package list.
+   */
+  transpilePackages?: string[];
+}
+/**
+ * The config object accepted by `withAsheeUI`: a standard `NextConfig`
+ * merged with AsheeUI overrides.
+ */
+type WithAsheeUIConfig = NextConfig & AsheeUIConfigOverrides;
+/**
+ * Structural view of the webpack config sections that AsheeUI patches.
+ *
+ * Kept deliberately minimal so this package does not need a webpack
+ * type dependency.
+ */
+interface WebpackConfigPatch {
+  /** Webpack resolution options. */
+  resolve?: {
+    /** Module alias map. */
+    alias?: Record<string, string>;
+  };
+  /** Webpack plugins to append to. */
+  plugins?: WebpackPluginLike[];
+}
+/**
+ * Structural view of the compilation object passed to webpack's
+ * `afterCompile` hook.
+ */
+interface WebpackCompilationLike {
+  /** Collector for files webpack should watch even when missing. */
+  missingDependencies: {
+    add: (path: string) => void;
+  };
+}
+/**
+ * Minimal structural view of a webpack plugin used by this package.
+ *
+ * Only the `apply` method and the `beforeCompile`/`afterCompile` hooks
+ * are modelled.
+ */
+interface WebpackPluginLike {
+  /** Install the plugin onto the compiler. */
+  apply: (compiler: {
+    hooks: {
+      /** Fired before each compilation begins. */
+      beforeCompile: {
+        tap: (name: string, callback: () => void) => void;
+      };
+      /** Fired after each compilation finishes. */
+      afterCompile: {
+        tap: (name: string, callback: (compilation: WebpackCompilationLike) => void) => void;
+      };
+    };
+  }) => void;
+}
+/**
+ * Minimal structural view of the webpack context object passed to the
+ * `webpack` config function by Next.
+ */
+interface WebpackContextLike {
+  /** `true` when Next is running a development build. */
+  dev: boolean;
+}
+//#endregion
+//#region src/webpack.d.ts
+/**
+ * Point `virtual:ashee-config` at the generated shim so app code keeps
+ * using the same import specifier as Vite.
+ *
+ * @param config - Webpack config section to patch (mutated in place).
+ * @param shimPath - Absolute path of the generated shim.
+ * @returns The same `config` object, with the alias registered.
+ *
+ * @example
+ * ```ts
+ * const config = addAsheeConfigAlias(
+ *   { resolve: { alias: {} } },
+ *   "/proj/.ashee/generated-config.mjs",
+ * );
+ * ```
+ */
+declare function addAsheeConfigAlias(config: WebpackConfigPatch, shimPath: string): WebpackConfigPatch;
+/**
+ * Create a dev-only webpack plugin that regenerates the shim before
+ * every compile so edits to an existing config file are always picked
+ * up.
+ *
+ * The plugin also registers every candidate filename as a webpack
+ * "missing dependency": the shim has no reference to a file that does
+ * not exist yet, so without this, *creating* the config file for the
+ * first time would never trigger a rebuild on its own. Writes are
+ * skipped when content is unchanged, keeping rebuilds cheap.
+ *
+ * @param regenerate - Callback that rewrites the shim file.
+ * @param candidatePaths - Absolute candidate config paths to watch as
+ *   missing dependencies.
+ * @returns A webpack plugin object.
+ */
+declare function createBeforeCompilePlugin(regenerate: () => void, candidatePaths: string[]): WebpackPluginLike;
+/**
+ * Create the webpack hook that Next invokes when building.
+ *
+ * The returned hook always adds the config alias; in dev mode it also
+ * installs the `beforeCompile` regeneration plugin and the
+ * missing-dependency watcher.
+ *
+ * @param options - Hook options.
+ * @param options.shimPath - Absolute path of the generated shim.
+ * @param options.candidatePaths - Absolute candidate config paths.
+ * @param options.root - Project root used when regenerating the shim.
+ * @param options.regenerate - Function that regenerates the shim for a
+ *   given root directory.
+ * @returns A webpack config hook matching Next's `webpack` signature.
+ */
+declare function createWebpackHook(options: {
+  shimPath: string;
+  candidatePaths: string[];
+  root?: string;
+  regenerate: (root?: string) => string;
+}): (config: WebpackConfigPatch, context: WebpackContextLike) => WebpackConfigPatch;
+//#endregion
+//#region src/with-ashee-ui.d.ts
+/**
+ * Wrap a `next.config.mjs`/`next.config.ts` object with AsheeUI
+ * integration.
+ *
+ * The wrapper:
+ * 1. Generates a config shim at `.ashee/generated-config.mjs` (same
+ *    resolution as `@asheeui/vite`'s `virtual:ashee-config`).
+ * 2. Adds a `virtual:ashee-config` alias for Webpack and Turbopack so
+ *    app code uses the identical import specifier in both bundlers.
+ *    Webpack gets an absolute path (it resolves against its own
+ *    context, not the `root` override), Turbopack gets a
+ *    project-root-relative one (it rejects absolute targets).
+ * 3. Merges `transpilePackages` so AsheeUI's source-shipping packages
+ *    are compiled by Next.
+ *
+ * @param config - Next config to wrap. AsheeUI override keys (`root`,
+ *   `transpilePackages`) are consumed and stripped from the returned
+ *   `NextConfig`. Defaults to `{}`.
+ * @returns A plain `NextConfig` with the AsheeUI integration applied.
+ *
+ * @example
+ * ```ts
+ * // next.config.ts
+ * import { withAsheeUI } from "@asheeui/next";
+ *
+ * export default withAsheeUI({
+ *   transpilePackages: ["@my-org/ui"],
+ * });
+ * ```
+ */
+declare function withAsheeUI(config?: WithAsheeUIConfig): NextConfig;
+//#endregion
+export { AsheeUIConfigOverrides, SHIM_RELATIVE_PATH, TurbopackPatch, VIRTUAL_ID, WebpackCompilationLike, WebpackConfigPatch, WebpackContextLike, WebpackPluginLike, WithAsheeUIConfig, addAsheeConfigAlias, addAsheeConfigResolveAlias, createBeforeCompilePlugin, createWebpackHook, generateShim, resolveCandidatePaths, resolveShimPath, withAsheeUI };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/generate.ts","../src/turbopack.ts","../src/types.ts","../src/webpack.ts","../src/with-ashee-ui.ts"],"mappings":";;;;;;;;;;cAYa;;;;;;;;;cAUA;;;;;;;iBAQG,gBAAgB;;;;;;;;;;;iBAchB,sBAAsB;;;;;;;;;;;;;iBAgCtB,aAAa;;;;;;;;;;UCnEZ;;EAEf,eAAe;;;;;;;;;;;;;;;;;;;;;iBAsBD,2BACd,QAAQ,gBACR,mBACC;;;;;;;UC9Bc;;;;;;;EAOf;;;;;EAKA;;;;;;KAOU,oBAAoB,aAAa;;;;;;;UAQ5B;;EAEf;;IAEE,QAAQ;;;EAGV,UAAU;;;;;;UAOK;;EAEf;IAAuB,MAAM;;;;;;;;;UASd;;EAEf,QAAQ;IACN;;MAEE;QACE,MAAM,cAAc;;;MAGtB;QACE,MACE,cACA,WAAW,aAAa;;;;;;;;;UAWjB;;EAEf;;;;;;;;;;;;;;;;;;;;iBCrDc,oBACd,QAAQ,oBACR,mBACC;;;;;;;;;;;;;;;;;iBAuBa,0BACd,wBACA,2BACC;;;;;;;;;;;;;;;;iBA8Ba,kBAAkB;EAChC;EACA;EACA;EACA,aAAa;KAEb,QAAQ,oBACR,SAAS,uBACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCxBW,YAAY,SAAQ,oBAAyB"}

package/dist/index.mjs

@@ -0,0 +1,282 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { CANDIDATES, discoverConfig } from "@asheeui/utils/node";
+//#region src/generate.ts
+/**
+* The import specifier used across AsheeUI for the config module.
+*
+* @example
+* ```ts
+* import config from "virtual:ashee-config";
+* ```
+*/
+const VIRTUAL_ID = "virtual:ashee-config";
+/**
+* Location of the generated shim, relative to the project root.
+*
+* Deliberately kept outside `node_modules`: package managers and CI
+* treat `node_modules` as fully disposable, and a shim the dev server
+* depends on should not live somewhere that can vanish out from under
+* it.
+*/
+const SHIM_RELATIVE_PATH = ".ashee/generated-config.mjs";
+/**
+* Resolve the absolute path of the generated shim for a project root.
+*
+* @param root - Project root directory. Defaults to `process.cwd()`.
+* @returns Absolute path of the shim file.
+*/
+function resolveShimPath(root) {
+	return resolve(root ?? process.cwd(), SHIM_RELATIVE_PATH);
+}
+/**
+* Resolve every candidate config filename to an absolute path under
+* `root`, whether or not the files currently exist.
+*
+* These paths are registered as webpack "missing dependencies" so that
+* creating a config file for the first time triggers a rebuild.
+*
+* @param root - Project root directory. Defaults to `process.cwd()`.
+* @returns Absolute paths for every known config filename.
+*/
+function resolveCandidatePaths(root) {
+	const base = root ?? process.cwd();
+	return CANDIDATES.map((file) => resolve(base, file));
+}
+/**
+* Build an import specifier for `toFile` relative to `fromFile`'s directory.
+*
+* Turbopack rejects absolute ("server-relative") import specifiers, so the
+* shim must reference the discovered config with a path relative to itself.
+*
+* @param fromFile - Absolute path of the importing file.
+* @param toFile - Absolute path of the imported file.
+* @returns A `./`-prefixed relative specifier.
+*/
+function toRelativeSpecifier(fromFile, toFile) {
+	const rel = relative(dirname(fromFile), toFile).replaceAll("\\", "/");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+/**
+* Regenerate the config shim, mirroring `@asheeui/vite`'s virtual module:
+* if a config file exists we re-export its default export, otherwise we
+* export `undefined`.
+*
+* The write is skipped when the content is unchanged, so webpack's
+* `beforeCompile` hook does not churn the file (or Turbopack's watcher)
+* on every rebuild.
+*
+* @param root - Project root directory. Defaults to `process.cwd()`.
+* @returns The absolute path of the regenerated shim file.
+*/
+function generateShim(root) {
+	const shimPath = resolveShimPath(root);
+	const configPath = discoverConfig(root);
+	const content = configPath ? `export { default } from ${JSON.stringify(toRelativeSpecifier(shimPath, configPath))};\n` : "export default undefined;\n";
+	if (!existsSync(shimPath) || readFileSync(shimPath, "utf8") !== content) {
+		mkdirSync(dirname(shimPath), { recursive: true });
+		writeFileSync(shimPath, content, "utf8");
+	}
+	return shimPath;
+}
+//#endregion
+//#region src/turbopack.ts
+/**
+* Point `virtual:ashee-config` at the generated shim inside a Turbopack
+* config section.
+*
+* The given `target` object is mutated and then returned so the caller
+* can use it in an inline expression.
+*
+* @param target - Turbopack config section (stable or experimental).
+* @param shimPath - Project-root-relative path of the generated shim.
+* @returns The same `target` object, with the alias registered.
+*
+* @example
+* ```ts
+* const turbopack = addAsheeConfigResolveAlias(
+*   { resolveAlias: {} },
+*   "./.ashee/generated-config.mjs",
+* );
+* ```
+*/
+function addAsheeConfigResolveAlias(target, shimPath) {
+	target.resolveAlias ??= {};
+	target.resolveAlias[VIRTUAL_ID] = shimPath;
+	return target;
+}
+//#endregion
+//#region src/webpack.ts
+/**
+* Exact-match alias key (`$`-suffixed) so a hypothetical future
+* `virtual:ashee-config/foo` import does not also resolve through this
+* alias.
+*/
+const EXACT_VIRTUAL_ID = `${VIRTUAL_ID}$`;
+/**
+* Point `virtual:ashee-config` at the generated shim so app code keeps
+* using the same import specifier as Vite.
+*
+* @param config - Webpack config section to patch (mutated in place).
+* @param shimPath - Absolute path of the generated shim.
+* @returns The same `config` object, with the alias registered.
+*
+* @example
+* ```ts
+* const config = addAsheeConfigAlias(
+*   { resolve: { alias: {} } },
+*   "/proj/.ashee/generated-config.mjs",
+* );
+* ```
+*/
+function addAsheeConfigAlias(config, shimPath) {
+	config.resolve ??= {};
+	config.resolve.alias ??= {};
+	config.resolve.alias[EXACT_VIRTUAL_ID] = shimPath;
+	return config;
+}
+/**
+* Create a dev-only webpack plugin that regenerates the shim before
+* every compile so edits to an existing config file are always picked
+* up.
+*
+* The plugin also registers every candidate filename as a webpack
+* "missing dependency": the shim has no reference to a file that does
+* not exist yet, so without this, *creating* the config file for the
+* first time would never trigger a rebuild on its own. Writes are
+* skipped when content is unchanged, keeping rebuilds cheap.
+*
+* @param regenerate - Callback that rewrites the shim file.
+* @param candidatePaths - Absolute candidate config paths to watch as
+*   missing dependencies.
+* @returns A webpack plugin object.
+*/
+function createBeforeCompilePlugin(regenerate, candidatePaths) {
+	return { apply(compiler) {
+		compiler.hooks.beforeCompile.tap("ashee:virtual-config", () => {
+			regenerate();
+		});
+		compiler.hooks.afterCompile.tap("ashee:virtual-config", (compilation) => {
+			for (const path of candidatePaths) compilation.missingDependencies.add(path);
+		});
+	} };
+}
+/**
+* Create the webpack hook that Next invokes when building.
+*
+* The returned hook always adds the config alias; in dev mode it also
+* installs the `beforeCompile` regeneration plugin and the
+* missing-dependency watcher.
+*
+* @param options - Hook options.
+* @param options.shimPath - Absolute path of the generated shim.
+* @param options.candidatePaths - Absolute candidate config paths.
+* @param options.root - Project root used when regenerating the shim.
+* @param options.regenerate - Function that regenerates the shim for a
+*   given root directory.
+* @returns A webpack config hook matching Next's `webpack` signature.
+*/
+function createWebpackHook(options) {
+	const { shimPath, candidatePaths, regenerate, root } = options;
+	return (config, context) => {
+		addAsheeConfigAlias(config, shimPath);
+		if (context.dev) {
+			config.plugins ??= [];
+			config.plugins.push(createBeforeCompilePlugin(() => regenerate(root), candidatePaths));
+		}
+		return config;
+	};
+}
+//#endregion
+//#region src/with-ashee-ui.ts
+/**
+* AsheeUI packages that ship TypeScript source and must be compiled by
+* Next.
+*
+* `transpilePackages` takes npm package names, deduped against any the
+* consumer provides.
+*/
+const ASHEE_TRANSPILE_PACKAGES = ["asheeui"];
+/**
+* Wrap a `next.config.mjs`/`next.config.ts` object with AsheeUI
+* integration.
+*
+* The wrapper:
+* 1. Generates a config shim at `.ashee/generated-config.mjs` (same
+*    resolution as `@asheeui/vite`'s `virtual:ashee-config`).
+* 2. Adds a `virtual:ashee-config` alias for Webpack and Turbopack so
+*    app code uses the identical import specifier in both bundlers.
+*    Webpack gets an absolute path (it resolves against its own
+*    context, not the `root` override), Turbopack gets a
+*    project-root-relative one (it rejects absolute targets).
+* 3. Merges `transpilePackages` so AsheeUI's source-shipping packages
+*    are compiled by Next.
+*
+* @param config - Next config to wrap. AsheeUI override keys (`root`,
+*   `transpilePackages`) are consumed and stripped from the returned
+*   `NextConfig`. Defaults to `{}`.
+* @returns A plain `NextConfig` with the AsheeUI integration applied.
+*
+* @example
+* ```ts
+* // next.config.ts
+* import { withAsheeUI } from "@asheeui/next";
+*
+* export default withAsheeUI({
+*   transpilePackages: ["@my-org/ui"],
+* });
+* ```
+*/
+function withAsheeUI(config = {}) {
+	const { root, transpilePackages: extraTranspilePackages, ...nextConfig } = config;
+	const baseDir = root ?? process.cwd();
+	const legacyConfig = nextConfig;
+	generateShim(baseDir);
+	const absoluteShimPath = resolveShimPath(baseDir);
+	const relativeShimPath = `./${SHIM_RELATIVE_PATH}`;
+	const candidatePaths = resolveCandidatePaths(baseDir);
+	const transpilePackages = [.../* @__PURE__ */ new Set([
+		...ASHEE_TRANSPILE_PACKAGES,
+		...legacyConfig.transpilePackages ?? [],
+		...extraTranspilePackages ?? []
+	])];
+	const userWebpack = nextConfig.webpack;
+	const webpack = ((config, context) => {
+		const patchConfig = config;
+		const patchContext = context;
+		const hook = createWebpackHook({
+			shimPath: absoluteShimPath,
+			candidatePaths,
+			root: baseDir,
+			regenerate: generateShim
+		});
+		if (userWebpack) return hook(userWebpack(patchConfig, patchContext), patchContext);
+		return hook(patchConfig, patchContext);
+	});
+	const turbopackResolveAlias = {
+		...nextConfig.turbopack?.resolveAlias ?? {},
+		[VIRTUAL_ID]: relativeShimPath
+	};
+	const turbopack = {
+		...nextConfig.turbopack,
+		resolveAlias: turbopackResolveAlias
+	};
+	const patchedConfig = {
+		...nextConfig,
+		transpilePackages,
+		webpack,
+		turbopack
+	};
+	if (legacyConfig.experimental?.turbo) {
+		const turboPatch = addAsheeConfigResolveAlias(legacyConfig.experimental.turbo, relativeShimPath);
+		patchedConfig.experimental = {
+			...nextConfig.experimental,
+			turbo: turboPatch
+		};
+	}
+	return patchedConfig;
+}
+//#endregion
+export { SHIM_RELATIVE_PATH, VIRTUAL_ID, addAsheeConfigAlias, addAsheeConfigResolveAlias, createBeforeCompilePlugin, createWebpackHook, generateShim, resolveCandidatePaths, resolveShimPath, withAsheeUI };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/generate.ts","../src/turbopack.ts","../src/webpack.ts","../src/with-ashee-ui.ts"],"sourcesContent":["import { existsSync, mkdirSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { dirname, relative, resolve } from \"node:path\";\nimport { CANDIDATES, discoverConfig } from \"@asheeui/utils/node\";\n\n/**\n * The import specifier used across AsheeUI for the config module.\n *\n * @example\n * ```ts\n * import config from \"virtual:ashee-config\";\n * ```\n */\nexport const VIRTUAL_ID = \"virtual:ashee-config\";\n\n/**\n * Location of the generated shim, relative to the project root.\n *\n * Deliberately kept outside `node_modules`: package managers and CI\n * treat `node_modules` as fully disposable, and a shim the dev server\n * depends on should not live somewhere that can vanish out from under\n * it.\n */\nexport const SHIM_RELATIVE_PATH = \".ashee/generated-config.mjs\";\n\n/**\n * Resolve the absolute path of the generated shim for a project root.\n *\n * @param root - Project root directory. Defaults to `process.cwd()`.\n * @returns Absolute path of the shim file.\n */\nexport function resolveShimPath(root?: string): string {\n  return resolve(root ?? process.cwd(), SHIM_RELATIVE_PATH);\n}\n\n/**\n * Resolve every candidate config filename to an absolute path under\n * `root`, whether or not the files currently exist.\n *\n * These paths are registered as webpack \"missing dependencies\" so that\n * creating a config file for the first time triggers a rebuild.\n *\n * @param root - Project root directory. Defaults to `process.cwd()`.\n * @returns Absolute paths for every known config filename.\n */\nexport function resolveCandidatePaths(root?: string): string[] {\n  const base = root ?? process.cwd();\n  return CANDIDATES.map((file) => resolve(base, file));\n}\n\n/**\n * Build an import specifier for `toFile` relative to `fromFile`'s directory.\n *\n * Turbopack rejects absolute (\"server-relative\") import specifiers, so the\n * shim must reference the discovered config with a path relative to itself.\n *\n * @param fromFile - Absolute path of the importing file.\n * @param toFile - Absolute path of the imported file.\n * @returns A `./`-prefixed relative specifier.\n */\nfunction toRelativeSpecifier(fromFile: string, toFile: string): string {\n  const rel = relative(dirname(fromFile), toFile).replaceAll(\"\\\\\", \"/\");\n  return rel.startsWith(\".\") ? rel : `./${rel}`;\n}\n\n/**\n * Regenerate the config shim, mirroring `@asheeui/vite`'s virtual module:\n * if a config file exists we re-export its default export, otherwise we\n * export `undefined`.\n *\n * The write is skipped when the content is unchanged, so webpack's\n * `beforeCompile` hook does not churn the file (or Turbopack's watcher)\n * on every rebuild.\n *\n * @param root - Project root directory. Defaults to `process.cwd()`.\n * @returns The absolute path of the regenerated shim file.\n */\nexport function generateShim(root?: string): string {\n  const shimPath = resolveShimPath(root);\n  const configPath = discoverConfig(root);\n\n  const content = configPath\n    ? `export { default } from ${JSON.stringify(\n        toRelativeSpecifier(shimPath, configPath),\n      )};\\n`\n    : \"export default undefined;\\n\";\n\n  if (!existsSync(shimPath) || readFileSync(shimPath, \"utf8\") !== content) {\n    mkdirSync(dirname(shimPath), { recursive: true });\n    writeFileSync(shimPath, content, \"utf8\");\n  }\n\n  return shimPath;\n}\n","import { VIRTUAL_ID } from \"./generate\";\n\n/**\n * The part of Next's Turbopack config that this package patches.\n *\n * Next exposes the same shape both at the stable `turbopack` key\n * (`>= 15.1`) and at the deprecated `experimental.turbo` key, so one\n * structural type covers both merge targets.\n */\nexport interface TurbopackPatch {\n  /** Alias map used to redirect module specifiers during resolution. */\n  resolveAlias?: Record<string, string>;\n}\n\n/**\n * Point `virtual:ashee-config` at the generated shim inside a Turbopack\n * config section.\n *\n * The given `target` object is mutated and then returned so the caller\n * can use it in an inline expression.\n *\n * @param target - Turbopack config section (stable or experimental).\n * @param shimPath - Project-root-relative path of the generated shim.\n * @returns The same `target` object, with the alias registered.\n *\n * @example\n * ```ts\n * const turbopack = addAsheeConfigResolveAlias(\n *   { resolveAlias: {} },\n *   \"./.ashee/generated-config.mjs\",\n * );\n * ```\n */\nexport function addAsheeConfigResolveAlias(\n  target: TurbopackPatch,\n  shimPath: string,\n): TurbopackPatch {\n  target.resolveAlias ??= {};\n  target.resolveAlias[VIRTUAL_ID] = shimPath;\n  return target;\n}\n","import { VIRTUAL_ID } from \"./generate\";\nimport type {\n  WebpackConfigPatch,\n  WebpackContextLike,\n  WebpackPluginLike,\n} from \"./types\";\n\n/**\n * Exact-match alias key (`$`-suffixed) so a hypothetical future\n * `virtual:ashee-config/foo` import does not also resolve through this\n * alias.\n */\nconst EXACT_VIRTUAL_ID = `${VIRTUAL_ID}$`;\n\n/**\n * Point `virtual:ashee-config` at the generated shim so app code keeps\n * using the same import specifier as Vite.\n *\n * @param config - Webpack config section to patch (mutated in place).\n * @param shimPath - Absolute path of the generated shim.\n * @returns The same `config` object, with the alias registered.\n *\n * @example\n * ```ts\n * const config = addAsheeConfigAlias(\n *   { resolve: { alias: {} } },\n *   \"/proj/.ashee/generated-config.mjs\",\n * );\n * ```\n */\nexport function addAsheeConfigAlias(\n  config: WebpackConfigPatch,\n  shimPath: string,\n): WebpackConfigPatch {\n  config.resolve ??= {};\n  config.resolve.alias ??= {};\n  config.resolve.alias[EXACT_VIRTUAL_ID] = shimPath;\n  return config;\n}\n\n/**\n * Create a dev-only webpack plugin that regenerates the shim before\n * every compile so edits to an existing config file are always picked\n * up.\n *\n * The plugin also registers every candidate filename as a webpack\n * \"missing dependency\": the shim has no reference to a file that does\n * not exist yet, so without this, *creating* the config file for the\n * first time would never trigger a rebuild on its own. Writes are\n * skipped when content is unchanged, keeping rebuilds cheap.\n *\n * @param regenerate - Callback that rewrites the shim file.\n * @param candidatePaths - Absolute candidate config paths to watch as\n *   missing dependencies.\n * @returns A webpack plugin object.\n */\nexport function createBeforeCompilePlugin(\n  regenerate: () => void,\n  candidatePaths: string[],\n): WebpackPluginLike {\n  return {\n    apply(compiler) {\n      compiler.hooks.beforeCompile.tap(\"ashee:virtual-config\", () => {\n        regenerate();\n      });\n      compiler.hooks.afterCompile.tap(\"ashee:virtual-config\", (compilation) => {\n        for (const path of candidatePaths) {\n          compilation.missingDependencies.add(path);\n        }\n      });\n    },\n  };\n}\n\n/**\n * Create the webpack hook that Next invokes when building.\n *\n * The returned hook always adds the config alias; in dev mode it also\n * installs the `beforeCompile` regeneration plugin and the\n * missing-dependency watcher.\n *\n * @param options - Hook options.\n * @param options.shimPath - Absolute path of the generated shim.\n * @param options.candidatePaths - Absolute candidate config paths.\n * @param options.root - Project root used when regenerating the shim.\n * @param options.regenerate - Function that regenerates the shim for a\n *   given root directory.\n * @returns A webpack config hook matching Next's `webpack` signature.\n */\nexport function createWebpackHook(options: {\n  shimPath: string;\n  candidatePaths: string[];\n  root?: string;\n  regenerate: (root?: string) => string;\n}): (\n  config: WebpackConfigPatch,\n  context: WebpackContextLike,\n) => WebpackConfigPatch {\n  const { shimPath, candidatePaths, regenerate, root } = options;\n\n  return (config, context) => {\n    addAsheeConfigAlias(config, shimPath);\n\n    if (context.dev) {\n      config.plugins ??= [];\n      config.plugins.push(\n        createBeforeCompilePlugin(() => regenerate(root), candidatePaths),\n      );\n    }\n\n    return config;\n  };\n}\n","import type { NextConfig } from \"next\";\nimport {\n  generateShim,\n  resolveCandidatePaths,\n  resolveShimPath,\n  SHIM_RELATIVE_PATH,\n  VIRTUAL_ID,\n} from \"./generate\";\nimport type { TurbopackPatch } from \"./turbopack\";\nimport { addAsheeConfigResolveAlias } from \"./turbopack\";\nimport type {\n  WebpackConfigPatch,\n  WebpackContextLike,\n  WithAsheeUIConfig,\n} from \"./types\";\nimport { createWebpackHook } from \"./webpack\";\n\n/**\n * AsheeUI packages that ship TypeScript source and must be compiled by\n * Next.\n *\n * `transpilePackages` takes npm package names, deduped against any the\n * consumer provides.\n */\nconst ASHEE_TRANSPILE_PACKAGES = [\"asheeui\"];\n\ntype NextWebpack = NonNullable<NextConfig[\"webpack\"]>;\n\n/**\n * Structural superset of `NextConfig` used to reach legacy keys.\n *\n * Next 15 kept `transpilePackages` on `NextConfig` and Turbopack behind\n * `experimental.turbo`; Next 16 removed both (Turbopack is the default).\n * This superset lets one code path type-check against either major\n * version of the peer dependency.\n */\ntype LegacyNextConfig = NextConfig & {\n  transpilePackages?: string[];\n  experimental?: {\n    turbo?: unknown;\n  };\n};\n\n/**\n * Wrap a `next.config.mjs`/`next.config.ts` object with AsheeUI\n * integration.\n *\n * The wrapper:\n * 1. Generates a config shim at `.ashee/generated-config.mjs` (same\n *    resolution as `@asheeui/vite`'s `virtual:ashee-config`).\n * 2. Adds a `virtual:ashee-config` alias for Webpack and Turbopack so\n *    app code uses the identical import specifier in both bundlers.\n *    Webpack gets an absolute path (it resolves against its own\n *    context, not the `root` override), Turbopack gets a\n *    project-root-relative one (it rejects absolute targets).\n * 3. Merges `transpilePackages` so AsheeUI's source-shipping packages\n *    are compiled by Next.\n *\n * @param config - Next config to wrap. AsheeUI override keys (`root`,\n *   `transpilePackages`) are consumed and stripped from the returned\n *   `NextConfig`. Defaults to `{}`.\n * @returns A plain `NextConfig` with the AsheeUI integration applied.\n *\n * @example\n * ```ts\n * // next.config.ts\n * import { withAsheeUI } from \"@asheeui/next\";\n *\n * export default withAsheeUI({\n *   transpilePackages: [\"@my-org/ui\"],\n * });\n * ```\n */\nexport function withAsheeUI(config: WithAsheeUIConfig = {}): NextConfig {\n  const {\n    root,\n    transpilePackages: extraTranspilePackages,\n    ...nextConfig\n  } = config;\n\n  const baseDir = root ?? process.cwd();\n\n  // Read-only access to config keys that only exist on Next 15.\n  const legacyConfig = nextConfig as LegacyNextConfig;\n\n  generateShim(baseDir);\n\n  const absoluteShimPath = resolveShimPath(baseDir);\n  const relativeShimPath = `./${SHIM_RELATIVE_PATH}`;\n  const candidatePaths = resolveCandidatePaths(baseDir);\n\n  const transpilePackages = [\n    ...new Set([\n      ...ASHEE_TRANSPILE_PACKAGES,\n      ...(legacyConfig.transpilePackages ?? []),\n      ...(extraTranspilePackages ?? []),\n    ]),\n  ];\n\n  const userWebpack = nextConfig.webpack;\n\n  const webpack: NextWebpack = ((config, context) => {\n    const patchConfig = config as unknown as WebpackConfigPatch;\n    const patchContext = context as unknown as WebpackContextLike;\n\n    const hook = createWebpackHook({\n      shimPath: absoluteShimPath,\n      candidatePaths,\n      root: baseDir,\n      regenerate: generateShim,\n    });\n\n    if (userWebpack) {\n      const userResult = userWebpack(\n        patchConfig as never,\n        patchContext as never,\n      );\n      return hook(userResult as WebpackConfigPatch, patchContext) as never;\n    }\n\n    return hook(patchConfig, patchContext) as never;\n  }) as NextWebpack;\n\n  // Turbopack: patch the stable key, and also the experimental fallback\n  // if the consumer configured it on an older Next 15.x.\n  const turbopackResolveAlias: Record<string, string> = {\n    ...(nextConfig.turbopack?.resolveAlias ?? {}),\n    [VIRTUAL_ID]: relativeShimPath,\n  };\n\n  const turbopack = {\n    ...nextConfig.turbopack,\n    resolveAlias: turbopackResolveAlias,\n  };\n\n  const patchedConfig: NextConfig = {\n    ...nextConfig,\n    transpilePackages,\n    webpack,\n    turbopack,\n  };\n\n  if (legacyConfig.experimental?.turbo) {\n    const turboPatch = addAsheeConfigResolveAlias(\n      legacyConfig.experimental.turbo as TurbopackPatch,\n      relativeShimPath,\n    ) as never;\n    patchedConfig.experimental = {\n      ...nextConfig.experimental,\n      turbo: turboPatch,\n    } as NextConfig[\"experimental\"];\n  }\n\n  return patchedConfig;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@asheeui/next",
+  "version": "0.3.1",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@asheeui/utils": "0.3.0"
+  },
+  "peerDependencies": {
+    "next": "^16.0.0",
+    "asheeui": "0.5.0"
+  },
+  "peerDependenciesMeta": {
+    "asheeui": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.2",
+    "next": "16.3.1",
+    "tsdown": "^0.22.14",
+    "typescript": "^5.0.0"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm,cjs --dts --clean",
+    "dev": "tsdown src/index.ts --format esm,cjs --dts --watch"
+  },
+  "module": "./dist/index.mjs"
+}