rebuildjs 0.22.2 → 0.24.1

package/browser/index.d.ts

@@ -1,11 +1,12 @@
 import type { ctx__be_T, ctx__get_T, ctx__set_T, lock_memosig_T, memo_T } from 'ctx-core/rmemo'
-import type { Metafile } from 'esbuild'
 import type { has_app_T, has_middleware_T } from '../ctx/index.js'
+import type { rebuildjs_metafile_T } from '../metafile_l0/index.js'
 export declare const browser__metafile_path$_:ctx__be_T<has_app_T, memo_T<string>, 'app'>
 export declare const browser__metafile_path_:ctx__get_T<has_app_T, string>
-export declare const browser__metafile$_:ctx__be_T<has_app_T, lock_memosig_T<Metafile|undefined>, 'app'>
-export declare const browser__metafile_:ctx__get_T<has_app_T, Metafile|undefined>
-export declare const browser__metafile__set:ctx__set_T<has_app_T, Metafile|undefined>
+export declare const browser__metafile$_:ctx__be_T<has_app_T, lock_memosig_T<rebuildjs_metafile_T|undefined>, 'app'>
+export declare const browser__metafile_:ctx__get_T<has_app_T, rebuildjs_metafile_T|undefined>
+export declare const browser__metafile__set:ctx__set_T<has_app_T, rebuildjs_metafile_T|undefined>
+export declare function browser__metafile__persist():Promise<void>
 export declare const browser__output__relative_path$_:ctx__be_T<has_middleware_T, memo_T<string>, 'middleware'>
 export declare const browser__output__relative_path_:ctx__get_T<has_middleware_T, string>
 export declare const browser__script$_:ctx__be_T<has_middleware_T, memo_T<string>, 'middleware'>

package/browser/index.js

@@ -1,9 +1,10 @@
 import { file_exists_ } from 'ctx-core/fs'
 import { nullish__none_, waitfor } from 'ctx-core/function'
 import { be_lock_memosig_triple_, be_memo_pair_ } from 'ctx-core/rmemo'
-import { readFile } from 'node:fs/promises'
+import { readFile, writeFile } from 'node:fs/promises'
 import { join, relative } from 'path'
 import { browser__relative_path_, browser_path_ } from '../app/index.js'
+import { app_ctx } from '../ctx/index.js'
 import { server__output_ } from '../server/index.js'
 export const [
 	browser__metafile_path$_,
@@ -16,22 +17,32 @@ export const [
 	browser__metafile$_,
 	browser__metafile_,
 	browser__metafile__set
-] = be_lock_memosig_triple_(()=>
-	undefined,
-async (ctx, browser__metafile$)=>{
-	browser__metafile__waitfor_promise?.cancel?.()
-	let metafile_path
-	if (!browser__metafile$.lock) {
-		metafile_path = browser__metafile_path_(ctx)
-		browser__metafile__waitfor_promise = waitfor(
-			()=>file_exists_(metafile_path),
-			200
-		).catch(()=>false)
-		if (await browser__metafile__waitfor_promise && metafile_path === browser__metafile_path_(ctx)) {
-			browser__metafile$._ = await readFile(metafile_path).then(buf=>JSON.parse(buf + ''))
+] = /** @type {be_lock_memosig_triple_T<rebuildjs_metafile_T>} */
+	be_lock_memosig_triple_(()=>
+		undefined,
+	async (ctx, browser__metafile$)=>{
+		browser__metafile__waitfor_promise?.cancel?.()
+		let metafile_path
+		if (!browser__metafile$.lock) {
+			metafile_path = browser__metafile_path_(ctx)
+			browser__metafile__waitfor_promise = waitfor(
+				()=>file_exists_(metafile_path),
+				200
+			).catch(()=>false)
+			if (await browser__metafile__waitfor_promise && metafile_path === browser__metafile_path_(ctx)) {
+				browser__metafile$._ = await readFile(metafile_path).then(buf=>JSON.parse(buf + ''))
+			}
 		}
-	}
-}, { ns: 'app', id: 'browser__metafile' })
+	}, { ns: 'app', id: 'browser__metafile' })
+export function browser__metafile__persist() {
+	return nullish__none_([
+		browser__metafile_path_(app_ctx),
+		browser__metafile_(app_ctx)
+	], (browser__metafile_path, browser__metafile)=>
+		writeFile(
+			browser__metafile_path,
+			JSON.stringify(browser__metafile, null, '\t')))
+}
 export const [
 	browser__output__relative_path$_,
 	browser__output__relative_path_

package/browser/index.test.ts

@@ -5,7 +5,12 @@ import { rmemo__wait } from 'ctx-core/rmemo'
 import esmock from 'esmock'
 import { test } from 'uvu'
 import { equal, throws } from 'uvu/assert'
-import { browser_metafile0, browser_metafile1, browser_metafile2, server_metafile0 } from '../_fixtures/index.js'
+import {
+	browser__metafile0,
+	browser__metafile1,
+	browser__metafile2,
+	server__metafile0
+} from '../_fixtures/metafiles.js'
 import { dist_path__set, is_prod__set } from '../app/index.js'
 import { app_ctx, middleware_ctx_ } from '../ctx/index.js'
 import { server__metafile__set, server__output_, server__output__relative_path__set } from '../server/index.js'
@@ -70,9 +75,9 @@ test('browser__metafile', async ()=>{
 					readFile_path = path
 					switch (path) {
 						case '/cwd/dist0/browser/metafile.json':
-							return Buffer.from(JSON.stringify(browser_metafile0), 'utf-8')
+							return Buffer.from(JSON.stringify(browser__metafile0), 'utf-8')
 						case '/cwd/dist1/browser/metafile.json':
-							return Buffer.from(JSON.stringify(browser_metafile1), 'utf-8')
+							return Buffer.from(JSON.stringify(browser__metafile1), 'utf-8')
 					}
 				}
 			},
@@ -84,65 +89,65 @@ test('browser__metafile', async ()=>{
 		_browser__metafile$_(app_ctx),
 		m=>m,
 		100)
-	equal(_browser__metafile$_(app_ctx)._, browser_metafile0)
-	equal(_browser__metafile_(app_ctx), browser_metafile0)
+	equal(_browser__metafile$_(app_ctx)._, browser__metafile0)
+	equal(_browser__metafile_(app_ctx), browser__metafile0)
 	equal(file_exists__path, '/cwd/dist0/browser/metafile.json')
 	equal(readFile_path, '/cwd/dist0/browser/metafile.json')
-	equal(_browser__metafile$_(app_ctx)._, browser_metafile0)
-	equal(_browser__metafile_(app_ctx), browser_metafile0)
+	equal(_browser__metafile$_(app_ctx)._, browser__metafile0)
+	equal(_browser__metafile_(app_ctx), browser__metafile0)
 	dist_path__set(app_ctx, '/cwd/dist1')
 	await rmemo__wait(
 		_browser__metafile$_(app_ctx),
-		m=>deep_equal(m, browser_metafile1),
+		m=>deep_equal(m, browser__metafile1),
 		100)
-	equal(_browser__metafile$_(app_ctx)._, browser_metafile1)
-	equal(_browser__metafile_(app_ctx), browser_metafile1)
+	equal(_browser__metafile$_(app_ctx)._, browser__metafile1)
+	equal(_browser__metafile_(app_ctx), browser__metafile1)
 	equal(file_exists__path, '/cwd/dist1/browser/metafile.json')
 	equal(readFile_path, '/cwd/dist1/browser/metafile.json')
 	dist_path__set(app_ctx, '/cwd/dist0')
 	await rmemo__wait(
 		_browser__metafile$_(app_ctx),
-		m=>deep_equal(m, browser_metafile0),
+		m=>deep_equal(m, browser__metafile0),
 		100)
-	equal(_browser__metafile$_(app_ctx)._, browser_metafile0)
-	equal(_browser__metafile_(app_ctx), browser_metafile0)
+	equal(_browser__metafile$_(app_ctx)._, browser__metafile0)
+	equal(_browser__metafile_(app_ctx), browser__metafile0)
 	equal(file_exists__path, '/cwd/dist0/browser/metafile.json')
 	equal(readFile_path, '/cwd/dist0/browser/metafile.json')
-	_browser__metafile__set(app_ctx, browser_metafile2)
-	equal(_browser__metafile$_(app_ctx)._, browser_metafile2)
-	equal(_browser__metafile_(app_ctx), browser_metafile2)
+	_browser__metafile__set(app_ctx, browser__metafile2)
+	equal(_browser__metafile$_(app_ctx)._, browser__metafile2)
+	equal(_browser__metafile_(app_ctx), browser__metafile2)
 	dist_path__set(app_ctx, '/cwd/dist1')
 	let error_msg:string|undefined = undefined
 	try {
 		await rmemo__wait(
 			_browser__metafile$_(app_ctx),
-			m=>deep_equal(m, browser_metafile1),
+			m=>deep_equal(m, browser__metafile1),
 			100)
 	} catch (e) {
 		error_msg = (e as Error).message
 	}
-	equal(_browser__metafile$_(app_ctx)._, browser_metafile2)
-	equal(_browser__metafile_(app_ctx), browser_metafile2)
+	equal(_browser__metafile$_(app_ctx)._, browser__metafile2)
+	equal(_browser__metafile_(app_ctx), browser__metafile2)
 	equal(error_msg, `Timeout 100ms`)
 	// @ts-expect-error TS2345
 	throws(()=>_browser__metafile$_(ctx_()))
 	// @ts-expect-error TS2345
 	throws(()=>_browser__metafile_(ctx_()))
 	// @ts-expect-error TS2345
-	throws(()=>_browser__metafile__set(ctx_(), browser_metafile0))
+	throws(()=>_browser__metafile__set(ctx_(), browser__metafile0))
 })
 test('browser__output__relative_path', ()=>{
 	const middleware_ctx = middleware_ctx_()
 	equal(browser__output__relative_path$_(middleware_ctx)._, undefined)
 	equal(browser__output__relative_path_(middleware_ctx), undefined)
-	server__metafile__set(middleware_ctx, server_metafile0)
+	server__metafile__set(middleware_ctx, server__metafile0)
 	equal(browser__output__relative_path$_(middleware_ctx)._, undefined)
 	equal(browser__output__relative_path_(middleware_ctx), undefined)
-	browser__metafile__set(middleware_ctx, browser_metafile0)
+	browser__metafile__set(middleware_ctx, browser__metafile0)
 	equal(browser__output__relative_path$_(middleware_ctx)._, undefined)
 	equal(browser__output__relative_path_(middleware_ctx), undefined)
 	server__output__relative_path__set(middleware_ctx, 'dist/server--dev/index.server-SVR0SVR0.js')
-	equal(server_metafile0.outputs['dist/server--dev/index.server-SVR0SVR0.js'], {
+	equal(server__metafile0.outputs['dist/server--dev/index.server-SVR0SVR0.js'], {
 		'imports': [],
 		'exports': [],
 		'entryPoint': 'src/app/index.server.ts',
@@ -154,7 +159,7 @@ test('browser__output__relative_path', ()=>{
 		},
 		'bytes': 98
 	})
-	equal(server__output_(middleware_ctx), server_metafile0.outputs['dist/server--dev/index.server-SVR0SVR0.js'])
+	equal(server__output_(middleware_ctx), server__metafile0.outputs['dist/server--dev/index.server-SVR0SVR0.js'])
 	equal(browser__output__relative_path$_(middleware_ctx)._, 'dist/browser--dev/index.browser-BRS0BRS0.js')
 	equal(browser__output__relative_path$_(middleware_ctx)._, 'dist/browser--dev/index.browser-BRS0BRS0.js')
 	// @ts-expect-error TS2345
@@ -166,10 +171,10 @@ test('browser__script', ()=>{
 	const middleware_ctx = middleware_ctx_()
 	equal(browser__script$_(middleware_ctx)._, undefined)
 	equal(browser__script_(middleware_ctx), undefined)
-	server__metafile__set(middleware_ctx, server_metafile0)
+	server__metafile__set(middleware_ctx, server__metafile0)
 	equal(browser__script$_(middleware_ctx)._, undefined)
 	equal(browser__script_(middleware_ctx), undefined)
-	browser__metafile__set(middleware_ctx, browser_metafile0)
+	browser__metafile__set(middleware_ctx, browser__metafile0)
 	equal(browser__script$_(middleware_ctx)._, undefined)
 	equal(browser__script_(middleware_ctx), undefined)
 	server__output__relative_path__set(middleware_ctx, 'dist/server--dev/index.server-SVR0SVR0.js')

package/build/index.d.ts

@@ -1,9 +1,16 @@
-import type { BuildOptions, Plugin } from 'esbuild'
-export declare function browser__build(config?:rebuildjs__build_config_T):Promise<void>
-export declare function server__build(config?:rebuildjs__build_config_T):Promise<void>
+import type { ctx__be_T, ctx__get_T, ctx__set_T, sig_T } from 'ctx-core/rmemo'
+import type { BuildContext, BuildOptions, Plugin } from 'esbuild'
+import type { has_app_T } from '../ctx/index.js'
+export declare const build_id$_:ctx__be_T<has_app_T, sig_T<string|undefined>, 'app'>
+export declare const build_id_:ctx__get_T<has_app_T, string|undefined>
+export declare const build_id__set:ctx__set_T<has_app_T, string|undefined>
+export declare function build_id__refresh():string
+export declare function browser__build(config?:rebuildjs_build_config_T):Promise<BuildContext>
+export declare function server__build(config?:rebuildjs_build_config_T):Promise<BuildContext>
 export declare function server__external_(config?:Partial<BuildOptions>):Promise<string[]>
-export declare function rebuildjs__plugin_():Plugin
-export type rebuildjs__build_config_T = Partial<BuildOptions>&{ rebuildjs?: rebuildjs__plugin_config_T }
-export type rebuildjs__plugin_config_T = {
+export declare function rebuildjs_plugin_():Plugin
+export type rebuildjs_build_config_T =
+	Partial<BuildOptions>&{ rebuildjs?:rebuildjs_plugin_config_T }
+export type rebuildjs_plugin_config_T = {
 	watch?:boolean
 }

package/build/index.js

@@ -1,16 +1,41 @@
+/// <reference types="../metafile_l0/index.d.ts" />
 /// <reference types="./index.d.ts" />
-/** @typedef {import('esbuild').BuildOptions}BuildOptions */
-/** @typedef {import('esbuild').Plugin}Plugin */
-import { build, context } from 'esbuild'
+import { nullish__none_, run } from 'ctx-core/function'
+import { be, be_sig_triple_, memo_ } from 'ctx-core/rmemo'
+import { short_uuid_ } from 'ctx-core/uuid'
+import { context } from 'esbuild'
 import { fdir } from 'fdir'
-import { link, mkdir, rm, writeFile } from 'node:fs/promises'
+import { link, mkdir, rm } from 'node:fs/promises'
 import { join, relative, resolve } from 'path'
 import { app_path_, browser_path_, cwd_, is_prod_, server__relative_path_, server_path_ } from '../app/index.js'
-import { browser__metafile__set } from '../browser/index.js'
+import {
+	browser__metafile_,
+	browser__metafile__persist,
+	browser__metafile__set,
+	browser__output__relative_path_
+} from '../browser/index.js'
 import { app_ctx } from '../ctx/index.js'
-import { server__metafile_, server__metafile__set } from '../server/index.js'
+import { metafile__build_id_ } from '../metafile/index.js'
+import {
+	server__metafile_,
+	server__metafile__persist,
+	server__metafile__set,
+	server__output__relative_path_M_middleware_ctx_
+} from '../server/index.js'
+export const [
+	build_id$_,
+	build_id_,
+	build_id__set,
+] = be_sig_triple_(()=>
+	undefined,
+{ id: 'build_id', ns: 'app' })
+export function build_id__refresh() {
+	const build_id = Date.now() + '-' + short_uuid_()
+	build_id__set(app_ctx, build_id)
+	return build_id
+}
 /**
- * @param {Plugin}config
+ * @param {import('esbuild').Plugin}config
  * @returns {Promise<void>}
  * @private
  */
@@ -31,8 +56,8 @@ export async function browser__build(config) {
 	for (const path of path_a) {
 		entryPoints.push(path)
 	}
-	const plugins = [rebuildjs__plugin_(), ...(esbuild__config.plugins || [])]
-	/** @type {BuildOptions} */
+	const plugins = [rebuildjs_plugin_(), ...(esbuild__config.plugins || [])]
+	/** @type {import('esbuild').BuildOptions} */
 	const esbuild_config = {
 		entryNames: '[name]-[hash]',
 		assetNames: '[name]-[hash]',
@@ -51,16 +76,17 @@ export async function browser__build(config) {
 		outdir: browser_path_(app_ctx),
 		plugins,
 	}
+	const esbuild_ctx = await context(esbuild_config)
 	if (rebuildjs?.watch ?? !is_prod_(app_ctx)) {
-		const esbuild_ctx = await context(esbuild_config)
 		await esbuild_ctx.watch()
 		console.log('browser__build|watch')
 	} else {
-		await build(esbuild_config)
+		await esbuild_ctx.rebuild()
 	}
+	return esbuild_ctx
 }
 /**
- * @param {rebuildjs__build_config_T}[config]
+ * @param {rebuildjs_build_config_T}[config]
  * @returns {Promise<void>}
  */
 export async function server__build(config) {
@@ -79,7 +105,7 @@ export async function server__build(config) {
 	for (const path of path_a) {
 		entryPoints.push(path)
 	}
-	const plugins = [rebuildjs__plugin_(), ...(esbuild__config.plugins || [])]
+	const plugins = [rebuildjs_plugin_(), ...(esbuild__config.plugins || [])]
 	const esbuild_config = {
 		entryNames: '[name]-[hash]',
 		assetNames: '[name]-[hash]',
@@ -98,54 +124,167 @@ export async function server__build(config) {
 		external: server__external_(esbuild__config),
 		plugins,
 	}
+	const esbuild_ctx = await context(esbuild_config)
 	if (rebuildjs?.watch ?? !is_prod_(app_ctx)) {
-		const esbuild_ctx = await context(esbuild_config)
 		await esbuild_ctx.watch()
 		console.log('server__build|watch')
 	} else {
-		await build(esbuild_config)
+		await esbuild_ctx.rebuild()
 	}
+	return esbuild_ctx
 }
 /**
- * @param {rebuildjs__build_config_T}[config]
+ * @param {rebuildjs_build_config_T}[config]
  * @returns {Promise<string[]>}
  */
 export function server__external_(config) {
 	return ['bun', 'node_modules/*', ...(config.external || [])]
 }
 /**
- * @returns {Plugin}
+ * @returns {import('esbuild').Plugin}
  * @private
+ *
  */
-export function rebuildjs__plugin_() {
-	return {
-		name: 'rebuildjs__plugin',
-		setup(build) {
+export function rebuildjs_plugin_() {
+	return { name: 'rebuildjs_plugin', setup: setup_() }
+	function setup_() {
+		/**
+		 * @param {import('esbuild').PluginBuild}build
+		 */
+		const setup = build=>{
 			build.onEnd(async result=>{
-				if (result.metafile) {
+				const {
+					/** @type {rebuildjs_metafile_T} */
+					metafile
+				} = result
+				if (metafile) {
 					const { outdir } = build.initialOptions
 					const resolve_outdir = resolve(outdir)
 					if (resolve_outdir === server_path_(app_ctx)) {
-						server__metafile__set(app_ctx, result.metafile)
+						const build_id = build_id__refresh()
+						await server__metafile__update(metafile, build_id)
+						if (build_id_(app_ctx) === build_id) {
+							await browser__metafile__update(browser__metafile_(app_ctx), build_id)
+						}
 					} else if (resolve_outdir === browser_path_(app_ctx)) {
-						browser__metafile__set(app_ctx, result.metafile)
-					}
-					if (outdir) {
-						await writeFile(
-							join(outdir, 'metafile.json'),
-							JSON.stringify(result.metafile, null, 2))
+						const build_id = build_id__refresh()
+						await browser__metafile__update(metafile, build_id)
+						if (build_id_(app_ctx) === build_id) {
+							await server__metafile__update(server__metafile_(app_ctx), build_id)
+						}
 					}
 				}
-				const outputs = server__metafile_(app_ctx)?.outputs ?? {}
-				for (let output__relative_path in outputs) {
-					if (/(\.js|\.mjs)(\.map)?$/.test(output__relative_path)) continue
-					const asset_path = join(cwd_(app_ctx), output__relative_path)
-					const link_path =
-						join(browser_path_(app_ctx), relative(server__relative_path_(app_ctx), output__relative_path))
-					await rm(link_path, { force: true })
-					await link(asset_path, link_path)
-				}
 			})
 		}
+		// Prevent GC
+		setup.rebuildjs__assets__link$ = rebuildjs__assets__link$_()
+		return setup
+		/**
+		 *
+		 * @returns {memo_T<void>}
+		 * @private
+		 */
+		function rebuildjs__assets__link$_() {
+			return (
+				be(app_ctx, ctx=>
+					run(memo_(assets__link$=>{
+						r()
+						return assets__link$
+						function r() {
+							nullish__none_([
+								build_id_(ctx),
+								metafile__build_id_(ctx),
+								server__metafile_(ctx),
+								cwd_(ctx),
+								browser_path_(ctx),
+								server__relative_path_(ctx),
+							], (
+								build_id,
+								metafile__build_id,
+								server__metafile,
+								cwd,
+								browser_path,
+								server__relative_path,
+							)=>{
+								if (build_id === metafile__build_id) {
+									run(async ()=>{
+										const outputs = server__metafile.outputs ?? {}
+										for (let output__relative_path in outputs) {
+											if (/(\.js|\.mjs)(\.map)?$/.test(output__relative_path)) continue
+											const server_asset_path = join(cwd, output__relative_path)
+											const browser_asset_path = join(
+												browser_path,
+												relative(server__relative_path, output__relative_path))
+											if (cancel_()) return
+											await rm(browser_asset_path, { force: true })
+											if (cancel_()) return
+											await link(server_asset_path, browser_asset_path)
+										}
+									})
+								}
+								function cancel_() {
+									return (
+										build_id_(ctx) !== build_id
+										|| metafile__build_id_(ctx) !== metafile__build_id
+										|| server__metafile_(ctx) !== server__metafile
+										|| cwd_(ctx) !== cwd
+										|| browser_path_(ctx) !== browser_path
+										|| server__relative_path_(ctx) !== server__relative_path
+									)
+								}
+							})
+						}
+					})),
+				{ id: 'rebuildjs__assets__link$', ns: 'app' })
+			)
+		}
+	}
+}
+async function server__metafile__update(server__metafile, build_id) {
+	if (!server__metafile) return
+	server__metafile = {
+		...server__metafile,
+		build_id,
+		rebuildjs_target: 'server'
+	}
+	server__metafile__set(app_ctx, server__metafile)
+	for (const [
+		server__output__relative_path,
+		middleware_ctx
+	] of server__output__relative_path_M_middleware_ctx_(app_ctx).entries()) {
+		const output = server__metafile.outputs[server__output__relative_path]
+		const { cssBundle } = output
+		if (cssBundle) {
+			output.esbuild_cssBundle = cssBundle
+			output.cssBundle_content = [
+				server__output__relative_path,
+				...(
+					browser__output__relative_path_(middleware_ctx)
+						? [browser__output__relative_path_(middleware_ctx)]
+						: [])
+			]
+		}
+	}
+	await server__metafile__persist()
+}
+async function browser__metafile__update(browser__metafile, build_id) {
+	if (!browser__metafile) return
+	browser__metafile = {
+		...browser__metafile,
+		build_id,
+		rebuildjs_target: 'browser'
+	}
+	browser__metafile__set(app_ctx, browser__metafile)
+	for (const middleware_ctx of server__output__relative_path_M_middleware_ctx_(app_ctx)?.values?.() ?? []) {
+		const browser__output__relative_path = browser__output__relative_path_(middleware_ctx)
+		if (browser__output__relative_path) {
+			const output = browser__metafile.outputs[browser__output__relative_path]
+			const { cssBundle } = output
+			if (cssBundle) {
+				output.esbuild_cssBundle = cssBundle
+				output.cssBundle_content = [browser__output__relative_path]
+			}
+		}
 	}
+	await browser__metafile__persist()
 }

package/build/index.test.ts

@@ -1,11 +1,93 @@
+import { ctx_ } from 'ctx-core/be'
+import { file_exists_ } from 'ctx-core/fs'
+import { sleep } from 'ctx-core/function'
+import { BuildContext } from 'esbuild'
+import { rm } from 'node:fs/promises'
+import { dirname, join } from 'path'
 import { test } from 'uvu'
-import { equal } from 'uvu/assert'
-import './index.js'
+import { equal, throws } from 'uvu/assert'
+import { cwd__set } from '../app/index.js'
+import { browser__metafile_ } from '../browser/index.js'
 import { app_ctx } from '../ctx/index.js'
+import { metafile__wait } from '../metafile/index.js'
+import { server__metafile_ } from '../server/index.js'
+import { browser__build, build_id$_, build_id_, build_id__refresh, build_id__set, server__build } from './index.js'
 test.after.each(()=>{
 	app_ctx.s.app.clear()
 })
-test('build|loads', ()=>{
-	equal(1, 1)
+test('build_id', ()=>{
+	equal(build_id$_(app_ctx)(), undefined)
+	equal(build_id_(app_ctx), undefined)
+	build_id__set(app_ctx, 'test_build_id')
+	equal(build_id$_(app_ctx)(), 'test_build_id')
+	equal(build_id_(app_ctx), 'test_build_id')
+	// @ts-expect-error TS2345
+	throws(()=>build_id$_(ctx_()))
+	// @ts-expect-error TS2345
+	throws(()=>build_id_(ctx_()))
+})
+test('build_id__refresh', ()=>{
+	equal(build_id_(app_ctx), undefined)
+	const build_id = build_id__refresh()
+	equal(build_id_(app_ctx), build_id)
+	equal(
+		parseInt(build_id.split('-')[0]) <= Date.now(),
+		true)
+	equal(
+		parseInt(build_id.split('-')[0]) > Date.now() - 1000,
+		true)
+})
+test('browser__build|server__build|rebuildjs_plugin_|metafile', async ()=>{
+	const test_dir = dirname(new URL(import.meta.url).pathname)
+	const cwd = join(test_dir, '../_fixtures')
+	cwd__set(app_ctx, cwd)
+	await rm(join(cwd, 'dist'), { recursive: true, force: true })
+	let server__build_context:BuildContext|undefined = undefined
+	let browser__build_context:BuildContext|undefined = undefined
+	try {
+		server__build_context = await server__build()
+		browser__build_context = await browser__build()
+		await metafile__wait()
+		equal(await file_exists_(join(cwd, 'dist')), true)
+		equal(await file_exists_(join(cwd, 'dist', 'browser--dev')), true)
+		equal(await file_exists_(join(cwd, 'dist', 'server--dev')), true)
+		const server__metafile = server__metafile_(app_ctx)!
+		equal(server__metafile.rebuildjs_target, 'server')
+		const browser__metafile = browser__metafile_(app_ctx)!
+		equal(browser__metafile.rebuildjs_target, 'browser')
+		equal(server__metafile.build_id != null, true)
+		equal(server__metafile.build_id, browser__metafile.build_id)
+		const server__output__relative_path =
+			Object.keys(server__metafile.outputs)
+				.find(server__output__relative_path=>
+					server__metafile.outputs[server__output__relative_path].entryPoint)!
+		equal(typeof server__output__relative_path, 'string')
+		const server__entryPoint__output =
+			server__metafile.outputs[server__output__relative_path]
+		equal(server__entryPoint__output != null, true)
+		equal(server__entryPoint__output.cssBundle != null, true)
+		equal(server__entryPoint__output.esbuild_cssBundle, server__entryPoint__output.cssBundle)
+		const browser__output__relative_path =
+			Object.keys(browser__metafile.outputs)
+				.find(browser__output__relative_path=>
+					browser__metafile.outputs[browser__output__relative_path].entryPoint)!
+		equal(typeof browser__output__relative_path, 'string')
+		const browser__entryPoint__output =
+			browser__metafile.outputs[browser__output__relative_path]
+		equal(browser__entryPoint__output != null, true)
+		equal(browser__entryPoint__output.cssBundle != null, true)
+		equal(browser__entryPoint__output.esbuild_cssBundle, browser__entryPoint__output.cssBundle)
+		equal(server__entryPoint__output.cssBundle_content, [
+			server__output__relative_path,
+			browser__output__relative_path
+		])
+		equal(browser__entryPoint__output.cssBundle_content, [
+			browser__output__relative_path
+		])
+	} finally {
+		await sleep(100)
+		server__build_context?.dispose?.()
+		browser__build_context?.dispose?.()
+	}
 })
 test.run()

package/ctx/index.js

@@ -1,6 +1,6 @@
 /// <reference types="./index.d.ts" />
 import { ns_ctx_ } from 'ctx-core/be'
-export const app_ctx = app_ctx_()
+export const app_ctx = globalThis.rebuildjs__app_ctx ??= app_ctx_()
 /**
  * @returns {app_ctx_T}
  * @private

package/metafile/index.d.ts

@@ -1 +1,6 @@
+import type { ctx__be_T, ctx__get_T, memo_T } from 'ctx-core/rmemo'
+import type { has_app_T } from '../ctx/index.js'
+export * from '../metafile_l0/index.js'
+export declare const metafile__build_id$_:ctx__be_T<has_app_T, memo_T<string>, 'app'>
+export declare const metafile__build_id_:ctx__get_T<has_app_T, string>
 export declare function metafile__wait(timeout?:number):Promise<void>

package/metafile/index.js

@@ -1,13 +1,27 @@
-import { memo_, rmemo__wait } from 'ctx-core/rmemo'
+import { nullish__none_ } from 'ctx-core/function'
+import { be_memo_pair_, rmemo__wait } from 'ctx-core/rmemo'
 import { browser__metafile_ } from '../browser/index.js'
 import { app_ctx } from '../ctx/index.js'
 import { server__metafile_ } from '../server/index.js'
+export const [
+	metafile__build_id$_,
+	metafile__build_id_,
+] = be_memo_pair_((ctx, build_id$)=>
+	nullish__none_([server__metafile_(ctx), browser__metafile_(ctx)],
+		(server__metafile, browser__metafile)=>
+			server__metafile.build_id === browser__metafile.build_id
+				? server__metafile.build_id
+				: build_id$.val),
+{ id: 'metafile__build_id', ns: 'app' })
 export async function metafile__wait(timeout = 5000) {
-	await rmemo__wait(memo_(()=>
-		server__metafile_(app_ctx) && browser__metafile_(app_ctx)),
-	val=>val !== undefined,
-	timeout
+	await rmemo__wait(
+		metafile__build_id$_(app_ctx),
+		metafile__build_id=>
+			metafile__build_id != null,
+		timeout
 	).catch(err=>{
-		throw Error('metafile__wait|browser & server metafile timeout', { cause: err })
+		throw Error(
+			'metafile__wait|browser__metafile & server__metafile timeout',
+			{ cause: err })
 	})
 }