initial commit

fluxer_app/scripts/build/config.ts

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as path from 'node:path';
+
+export const ROOT_DIR = path.resolve(import.meta.dirname, '..', '..');
+export const SRC_DIR = path.join(ROOT_DIR, 'src');
+export const DIST_DIR = path.join(ROOT_DIR, 'dist');
+export const ASSETS_DIR = path.join(DIST_DIR, 'assets');
+export const PKGS_DIR = path.join(ROOT_DIR, 'pkgs');
+export const PUBLIC_DIR = path.join(ROOT_DIR, 'assets');
+
+export const CDN_ENDPOINT = 'https://fluxerstatic.com';
+
+export const DEV_PORT = 3000;
+
+export const RESOLVE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.json', '.mjs', '.cjs'];
+
+export const LOCALES = [
+	'ar',
+	'bg',
+	'cs',
+	'da',
+	'de',
+	'el',
+	'en-GB',
+	'en-US',
+	'es-419',
+	'es-ES',
+	'fi',
+	'fr',
+	'he',
+	'hi',
+	'hr',
+	'hu',
+	'id',
+	'it',
+	'ja',
+	'ko',
+	'lt',
+	'nl',
+	'no',
+	'pl',
+	'pt-BR',
+	'ro',
+	'ru',
+	'sv-SE',
+	'th',
+	'tr',
+	'uk',
+	'vi',
+	'zh-CN',
+	'zh-TW',
+];
+
+export const FILE_LOADERS: Record<string, 'file'> = {
+	'.woff': 'file',
+	'.woff2': 'file',
+	'.ttf': 'file',
+	'.eot': 'file',
+	'.png': 'file',
+	'.jpg': 'file',
+	'.jpeg': 'file',
+	'.gif': 'file',
+	'.webp': 'file',
+	'.ico': 'file',
+	'.mp3': 'file',
+	'.wav': 'file',
+	'.ogg': 'file',
+	'.mp4': 'file',
+	'.webm': 'file',
+};

fluxer_app/scripts/build/rspack/externals.mjs

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+const EXTERNAL_MODULES = [
+	'@lingui/cli',
+	'@lingui/conf',
+	'cosmiconfig',
+	'jiti',
+	'node:*',
+	'crypto',
+	'path',
+	'fs',
+	'os',
+	'vm',
+	'perf_hooks',
+	'util',
+	'events',
+	'stream',
+	'buffer',
+	'child_process',
+	'cluster',
+	'dgram',
+	'dns',
+	'http',
+	'https',
+	'module',
+	'net',
+	'repl',
+	'tls',
+	'url',
+	'worker_threads',
+	'readline',
+	'zlib',
+	'resolve',
+];
+
+const EXTERNAL_PATTERNS = [/^node:.*/];
+
+export class ExternalsPlugin {
+	apply(compiler) {
+		const existingExternals = compiler.options.externals || [];
+		const externalsArray = Array.isArray(existingExternals) ? existingExternals : [existingExternals];
+		compiler.options.externals = [...externalsArray, ...EXTERNAL_MODULES, ...EXTERNAL_PATTERNS];
+	}
+}
+
+export function externalsPlugin() {
+	return new ExternalsPlugin();
+}

fluxer_app/scripts/build/rspack/lingui.mjs

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function getLinguiSwcPluginConfig() {
+	return [
+		'@lingui/swc-plugin',
+		{
+			localeDir: 'src/locales/{locale}/messages',
+			runtimeModules: {
+				i18n: ['@lingui/core', 'i18n'],
+				trans: ['@lingui/react', 'Trans'],
+			},
+			stripNonEssentialFields: false,
+		},
+	];
+}
+
+export function createPoFileRule() {
+	return {
+		test: /\.po$/,
+		type: 'javascript/auto',
+		use: {
+			loader: path.join(__dirname, 'po-loader.mjs'),
+		},
+	};
+}

fluxer_app/scripts/build/rspack/po-loader.mjs

@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import fs from 'node:fs/promises';
+
+export default function poLoader(source) {
+	const callback = this.async();
+
+	(async () => {
+		try {
+			this.cacheable?.();
+
+			const poPath = this.resourcePath;
+			const compiledPath = `${poPath}.mjs`;
+
+			this.addDependency?.(poPath);
+
+			try {
+				await fs.access(compiledPath);
+				this.addDependency?.(compiledPath);
+				const compiledSource = await fs.readFile(compiledPath, 'utf8');
+				callback(null, compiledSource);
+				return;
+			} catch {}
+
+			const content = Buffer.isBuffer(source) ? source.toString('utf8') : String(source);
+			const messages = parsePoFile(content);
+
+			const code = `export const messages = ${JSON.stringify(messages, null, 2)};\nexport default messages;\n`;
+
+			callback(null, code);
+		} catch (err) {
+			callback(err);
+		}
+	})();
+}
+
+function parsePoFile(content) {
+	const messages = {};
+	const entries = splitEntries(content);
+
+	for (const entry of entries) {
+		const parsed = parseEntry(entry);
+		if (!parsed) continue;
+		messages[parsed.key] = parsed.value;
+	}
+
+	return messages;
+}
+
+function splitEntries(content) {
+	const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+	return normalized
+		.split(/\n{2,}/g)
+		.map((s) => s.trim())
+		.filter(Boolean);
+}
+
+function parseEntry(entry) {
+	const lines = entry.split('\n');
+
+	let msgctxt = null;
+	let msgid = null;
+	let msgidPlural = null;
+
+	const msgstrMap = new Map();
+
+	let active = null;
+	let activeMsgstrIndex = 0;
+
+	for (const rawLine of lines) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith('#')) continue;
+
+		if (line.startsWith('msgctxt ')) {
+			active = 'msgctxt';
+			activeMsgstrIndex = 0;
+			msgctxt = extractPoString(line.slice('msgctxt '.length));
+			continue;
+		}
+
+		if (line.startsWith('msgid_plural ')) {
+			active = 'msgidPlural';
+			activeMsgstrIndex = 0;
+			msgidPlural = extractPoString(line.slice('msgid_plural '.length));
+			continue;
+		}
+
+		if (line.startsWith('msgid ')) {
+			active = 'msgid';
+			activeMsgstrIndex = 0;
+			msgid = extractPoString(line.slice('msgid '.length));
+			continue;
+		}
+
+		const msgstrIndexed = line.match(/^msgstr\[(\d+)\]\s+/);
+		if (msgstrIndexed) {
+			active = 'msgstr';
+			activeMsgstrIndex = Number(msgstrIndexed[1]);
+			const rest = line.slice(msgstrIndexed[0].length);
+			msgstrMap.set(activeMsgstrIndex, extractPoString(rest));
+			continue;
+		}
+
+		if (line.startsWith('msgstr ')) {
+			active = 'msgstr';
+			activeMsgstrIndex = 0;
+			msgstrMap.set(0, extractPoString(line.slice('msgstr '.length)));
+			continue;
+		}
+
+		if (line.startsWith('"') && line.endsWith('"')) {
+			const part = extractPoString(line);
+
+			if (active === 'msgctxt') msgctxt = (msgctxt ?? '') + part;
+			else if (active === 'msgid') msgid = (msgid ?? '') + part;
+			else if (active === 'msgidPlural') msgidPlural = (msgidPlural ?? '') + part;
+			else if (active === 'msgstr') msgstrMap.set(activeMsgstrIndex, (msgstrMap.get(activeMsgstrIndex) ?? '') + part);
+		}
+	}
+
+	if (msgid == null) return null;
+
+	if (msgid === '') return null;
+
+	const key = msgctxt ? `${msgctxt}\u0004${msgid}` : msgid;
+
+	if (msgidPlural != null) {
+		const keys = Array.from(msgstrMap.keys());
+		const maxIndex = keys.length ? Math.max(...keys.map((n) => Number(n))) : 0;
+
+		const arr = [];
+		for (let i = 0; i <= maxIndex; i++) {
+			arr[i] = msgstrMap.get(i) ?? '';
+		}
+
+		return {key, value: arr};
+	}
+
+	return {key, value: msgstrMap.get(0) ?? ''};
+}
+
+function extractPoString(str) {
+	const trimmed = str.trim();
+	if (!trimmed.startsWith('"') || !trimmed.endsWith('"')) return trimmed;
+
+	return trimmed.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+}

fluxer_app/scripts/build/rspack/static-files.mjs

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import {sources} from '@rspack/core';
+
+function normalizeEndpoint(cdnEndpoint) {
+	if (!cdnEndpoint) return '';
+	return cdnEndpoint.endsWith('/') ? cdnEndpoint.slice(0, -1) : cdnEndpoint;
+}
+
+function generateManifest(cdnEndpointRaw) {
+	const cdnEndpoint = normalizeEndpoint(cdnEndpointRaw);
+
+	const manifest = {
+		name: 'Fluxer',
+		short_name: 'Fluxer',
+		description:
+			'Chat that puts you first. Built for friends, groups, and communities. Text, voice, and video. Open source and community-funded.',
+		start_url: '/',
+		display: 'standalone',
+		orientation: 'portrait-primary',
+		theme_color: '#4641D9',
+		background_color: '#2b2d31',
+		categories: ['social', 'communication'],
+		lang: 'en',
+		scope: '/',
+		icons: [
+			{
+				src: `${cdnEndpoint}/web/android-chrome-192x192.png`,
+				sizes: '192x192',
+				type: 'image/png',
+				purpose: 'maskable any',
+			},
+			{
+				src: `${cdnEndpoint}/web/android-chrome-512x512.png`,
+				sizes: '512x512',
+				type: 'image/png',
+				purpose: 'maskable any',
+			},
+			{
+				src: `${cdnEndpoint}/web/apple-touch-icon.png`,
+				sizes: '180x180',
+				type: 'image/png',
+			},
+			{
+				src: `${cdnEndpoint}/web/favicon-32x32.png`,
+				sizes: '32x32',
+				type: 'image/png',
+			},
+			{
+				src: `${cdnEndpoint}/web/favicon-16x16.png`,
+				sizes: '16x16',
+				type: 'image/png',
+			},
+		],
+	};
+
+	return JSON.stringify(manifest, null, 2);
+}
+
+function generateBrowserConfig(cdnEndpointRaw) {
+	const cdnEndpoint = normalizeEndpoint(cdnEndpointRaw);
+
+	return `<?xml version="1.0" encoding="utf-8"?>
+<browserconfig>
+  <msapplication>
+    <tile>
+      <square150x150logo src="${cdnEndpoint}/web/mstile-150x150.png"/>
+      <TileColor>#4641D9</TileColor>
+    </tile>
+  </msapplication>
+</browserconfig>`;
+}
+
+function generateRobotsTxt() {
+	return 'User-agent: *\nAllow: /\n';
+}
+
+export class StaticFilesPlugin {
+	constructor(options) {
+		this.cdnEndpoint = options?.cdnEndpoint ?? '';
+	}
+
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap('StaticFilesPlugin', (compilation) => {
+			compilation.hooks.processAssets.tap(
+				{
+					name: 'StaticFilesPlugin',
+					stage: compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+				},
+				() => {
+					compilation.emitAsset('manifest.json', new sources.RawSource(generateManifest(this.cdnEndpoint)));
+					compilation.emitAsset('browserconfig.xml', new sources.RawSource(generateBrowserConfig(this.cdnEndpoint)));
+					compilation.emitAsset('robots.txt', new sources.RawSource(generateRobotsTxt()));
+				},
+			);
+		});
+	}
+}
+
+export function staticFilesPlugin(options) {
+	return new StaticFilesPlugin(options);
+}

fluxer_app/scripts/build/rspack/wasm.mjs

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default function wasmLoader(_source) {
+	const callback = this.async();
+
+	if (!callback) {
+		throw new Error('Async loader not supported');
+	}
+
+	const wasmPath = this.resourcePath;
+
+	fs.promises
+		.readFile(wasmPath)
+		.then((wasmContent) => {
+			const base64 = wasmContent.toString('base64');
+			const code = `
+				const wasmBase64 = "${base64}";
+				const wasmBinary = Uint8Array.from(atob(wasmBase64), c => c.charCodeAt(0));
+				export default wasmBinary;
+			`;
+			callback(null, code);
+		})
+		.catch((err) => {
+			callback(err);
+		});
+}
+
+export function wasmModuleRule() {
+	return {
+		test: /\.wasm$/,
+		exclude: [/node_modules/],
+		type: 'javascript/auto',
+		use: [
+			{
+				loader: path.join(__dirname, 'wasm.mjs'),
+			},
+		],
+	};
+}

fluxer_app/scripts/build/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"compilerOptions": {
+		"target": "ES2023",
+		"module": "ESNext",
+		"lib": ["ES2023"],
+		"noEmit": true,
+		"moduleResolution": "Bundler",
+		"moduleDetection": "force",
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"esModuleInterop": true,
+		"allowSyntheticDefaultImports": true,
+		"strict": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true
+	},
+	"include": ["./**/*.ts"]
+}

fluxer_app/scripts/build/types.d.ts

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare module 'postcss' {
+	interface ProcessOptions {
+		from?: string;
+		to?: string;
+		map?: boolean | {inline?: boolean; prev?: boolean | string | object; annotation?: boolean | string};
+		parser?: unknown;
+		stringifier?: unknown;
+		syntax?: unknown;
+	}
+
+	interface Result {
+		css: string;
+		map?: unknown;
+		root: unknown;
+		processor: unknown;
+		messages: Array<unknown>;
+		opts: ProcessOptions;
+	}
+
+	interface Plugin {
+		postcssPlugin: string;
+		Once?(root: unknown, helpers: unknown): void | Promise<void>;
+		Root?(root: unknown, helpers: unknown): void | Promise<void>;
+		RootExit?(root: unknown, helpers: unknown): void | Promise<void>;
+		AtRule?(atRule: unknown, helpers: unknown): void | Promise<void>;
+		AtRuleExit?(atRule: unknown, helpers: unknown): void | Promise<void>;
+		Rule?(rule: unknown, helpers: unknown): void | Promise<void>;
+		RuleExit?(rule: unknown, helpers: unknown): void | Promise<void>;
+		Declaration?(declaration: unknown, helpers: unknown): void | Promise<void>;
+		DeclarationExit?(declaration: unknown, helpers: unknown): void | Promise<void>;
+		Comment?(comment: unknown, helpers: unknown): void | Promise<void>;
+		CommentExit?(comment: unknown, helpers: unknown): void | Promise<void>;
+	}
+
+	interface Processor {
+		process(css: string, options?: ProcessOptions): Promise<Result>;
+	}
+
+	function postcss(plugins?: Array<Plugin | ((options?: unknown) => Plugin)>): Processor;
+
+	export default postcss;
+}
+
+declare module 'postcss-modules' {
+	interface PostcssModulesOptions {
+		localsConvention?:
+			| 'camelCase'
+			| 'camelCaseOnly'
+			| 'dashes'
+			| 'dashesOnly'
+			| ((originalClassName: string, generatedClassName: string, inputFile: string) => string);
+		generateScopedName?: string | ((name: string, filename: string, css: string) => string);
+		getJSON?(cssFileName: string, json: Record<string, string>, outputFileName?: string): void;
+		hashPrefix?: string;
+		scopeBehaviour?: 'global' | 'local';
+		globalModulePaths?: Array<RegExp>;
+		root?: string;
+	}
+
+	function postcssModules(options?: PostcssModulesOptions): import('postcss').Plugin;
+
+	export default postcssModules;
+}

fluxer_app/scripts/build/utils/assets.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {ASSETS_DIR, DIST_DIR, PKGS_DIR, PUBLIC_DIR} from '../config';
+
+export async function copyPublicAssets(): Promise<void> {
+	if (!fs.existsSync(PUBLIC_DIR)) {
+		return;
+	}
+
+	const files = await fs.promises.readdir(PUBLIC_DIR, {recursive: true});
+	for (const file of files) {
+		const srcPath = path.join(PUBLIC_DIR, file.toString());
+		const destPath = path.join(DIST_DIR, file.toString());
+
+		const stat = await fs.promises.stat(srcPath);
+		if (stat.isFile()) {
+			await fs.promises.mkdir(path.dirname(destPath), {recursive: true});
+			await fs.promises.copyFile(srcPath, destPath);
+		}
+	}
+}
+
+export async function copyWasmFiles(): Promise<void> {
+	const libfluxcoreDir = path.join(PKGS_DIR, 'libfluxcore');
+	const wasmFile = path.join(libfluxcoreDir, 'libfluxcore_bg.wasm');
+
+	if (fs.existsSync(wasmFile)) {
+		await fs.promises.copyFile(wasmFile, path.join(ASSETS_DIR, 'libfluxcore_bg.wasm'));
+	}
+}
+
+export async function removeUnusedCssAssets(assetsDir: string, keepFiles: Array<string>): Promise<void> {
+	if (!fs.existsSync(assetsDir)) {
+		return;
+	}
+
+	const keepNames = new Set<string>();
+	for (const file of keepFiles) {
+		const base = path.basename(file);
+		keepNames.add(base);
+		if (base.endsWith('.css')) {
+			keepNames.add(`${base}.map`);
+		}
+	}
+
+	const entries = await fs.promises.readdir(assetsDir);
+	for (const entry of entries) {
+		if (!entry.endsWith('.css') && !entry.endsWith('.css.map')) {
+			continue;
+		}
+		if (keepNames.has(entry)) {
+			continue;
+		}
+		await fs.promises.rm(path.join(assetsDir, entry), {force: true});
+	}
+}

fluxer_app/scripts/build/utils/css-dts.ts

@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import postcss from 'postcss';
+import postcssModules from 'postcss-modules';
+import {PKGS_DIR, SRC_DIR} from '../config';
+
+const RESERVED_KEYWORDS = new Set([
+	'break',
+	'case',
+	'catch',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'export',
+	'extends',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'import',
+	'in',
+	'instanceof',
+	'new',
+	'return',
+	'super',
+	'switch',
+	'this',
+	'throw',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'yield',
+	'enum',
+	'implements',
+	'interface',
+	'let',
+	'package',
+	'private',
+	'protected',
+	'public',
+	'static',
+	'await',
+	'class',
+	'const',
+]);
+
+function isValidIdentifier(name: string): boolean {
+	if (RESERVED_KEYWORDS.has(name)) {
+		return false;
+	}
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+
+function generateDtsContent(classNames: Record<string, string>): string {
+	const validClassNames = Object.keys(classNames).filter(isValidIdentifier);
+	const typeMembers = validClassNames.map((name) => `\treadonly ${name}: string;`).join('\n');
+	const defaultExportType =
+		validClassNames.length > 0 ? `{\n${typeMembers}\n\treadonly [key: string]: string;\n}` : 'Record<string, string>';
+
+	return `declare const styles: ${defaultExportType};\nexport default styles;\n`;
+}
+
+async function findCssModuleFiles(dir: string): Promise<Array<string>> {
+	const files: Array<string> = [];
+
+	async function walk(currentDir: string): Promise<void> {
+		const entries = await fs.promises.readdir(currentDir, {withFileTypes: true});
+
+		for (const entry of entries) {
+			const fullPath = path.join(currentDir, entry.name);
+
+			if (entry.isDirectory()) {
+				if (entry.name !== 'node_modules' && entry.name !== 'dist' && entry.name !== '.git') {
+					await walk(fullPath);
+				}
+			} else if (entry.name.endsWith('.module.css')) {
+				files.push(fullPath);
+			}
+		}
+	}
+
+	await walk(dir);
+	return files;
+}
+
+async function generateDtsForFile(cssPath: string): Promise<void> {
+	const cssContent = await fs.promises.readFile(cssPath, 'utf-8');
+	let exportedClassNames: Record<string, string> = {};
+
+	await postcss([
+		postcssModules({
+			localsConvention: 'camelCaseOnly',
+			generateScopedName: '[name]__[local]___[hash:base64:5]',
+			getJSON(_cssFileName: string, json: Record<string, string>) {
+				exportedClassNames = json;
+			},
+		}),
+	]).process(cssContent, {from: cssPath});
+
+	const dtsPath = `${cssPath}.d.ts`;
+	const dtsContent = generateDtsContent(exportedClassNames);
+	await fs.promises.writeFile(dtsPath, dtsContent);
+}
+
+export async function generateCssDtsForFile(cssPath: string): Promise<void> {
+	if (!cssPath.endsWith('.module.css')) {
+		return;
+	}
+	await generateDtsForFile(cssPath);
+}
+
+export async function generateAllCssDts(): Promise<void> {
+	const srcFiles = await findCssModuleFiles(SRC_DIR);
+	const pkgsFiles = await findCssModuleFiles(PKGS_DIR);
+	const allFiles = [...srcFiles, ...pkgsFiles];
+
+	console.log(`Generating .d.ts files for ${allFiles.length} CSS modules...`);
+
+	await Promise.all(allFiles.map(generateDtsForFile));
+
+	console.log(`Generated ${allFiles.length} CSS module type definitions.`);
+}

fluxer_app/scripts/build/utils/html.ts

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {ASSETS_DIR, CDN_ENDPOINT, ROOT_DIR} from '../config';
+
+interface BuildOutput {
+	mainScript: string | null;
+	cssFiles: Array<string>;
+	jsFiles: Array<string>;
+	cssBundleFile: string | null;
+	vendorScripts: Array<string>;
+}
+
+interface GenerateHtmlOptions {
+	buildOutput: BuildOutput;
+	production: boolean;
+}
+
+async function findCssModulesFile(): Promise<string | null> {
+	if (!fs.existsSync(ASSETS_DIR)) {
+		return null;
+	}
+	const files = await fs.promises.readdir(ASSETS_DIR);
+	const stylesFiles = files.filter((name) => name.startsWith('styles.') && name.endsWith('.css'));
+	if (stylesFiles.length === 0) {
+		return null;
+	}
+
+	let latestFile: string | null = null;
+	let latestMtime = 0;
+
+	for (const fileName of stylesFiles) {
+		const filePath = path.join(ASSETS_DIR, fileName);
+		const stats = await fs.promises.stat(filePath);
+		if (latestFile === null || stats.mtimeMs > latestMtime) {
+			latestFile = fileName;
+			latestMtime = stats.mtimeMs;
+		}
+	}
+
+	return latestFile ? `assets/${latestFile}` : null;
+}
+
+export async function generateHtml(options: GenerateHtmlOptions): Promise<string> {
+	const {buildOutput, production} = options;
+
+	const indexHtmlPath = path.join(ROOT_DIR, 'index.html');
+	let html = await fs.promises.readFile(indexHtmlPath, 'utf-8');
+
+	const baseUrl = production ? `${CDN_ENDPOINT}/` : '/';
+
+	const cssModulesFile = buildOutput.cssBundleFile ?? (await findCssModulesFile());
+	const cssFiles = cssModulesFile ? [cssModulesFile] : buildOutput.cssFiles;
+
+	const cssLinks = cssFiles.map((file) => `<link rel="stylesheet" href="${baseUrl}${file}">`).join('\n');
+
+	const crossOriginAttr = production && baseUrl.startsWith('http') ? ' crossorigin="anonymous"' : '';
+
+	const jsScripts = buildOutput.mainScript
+		? `<script type="module" src="${baseUrl}${buildOutput.mainScript}"${crossOriginAttr}></script>`
+		: '';
+
+	const buildScriptPreload = (file: string): string =>
+		`<link rel="preload" as="script" href="${baseUrl}${file}"${crossOriginAttr}>`;
+
+	const preloadScripts = [
+		...(buildOutput.vendorScripts ?? []).map(buildScriptPreload),
+		...buildOutput.jsFiles.filter((file) => !file.includes('messages')).map(buildScriptPreload),
+	].join('\n');
+
+	html = html.replace(/<script type="module" src="\/src\/index\.tsx"><\/script>/, jsScripts);
+	const headInsert = [cssLinks, preloadScripts].filter(Boolean).join('\n');
+	html = html.replace('</head>', `${headInsert}\n</head>`);
+
+	return html;
+}

fluxer_app/scripts/build/utils/index.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+export {copyPublicAssets, copyWasmFiles, removeUnusedCssAssets} from './assets';
+export {generateAllCssDts, generateCssDtsForFile} from './css-dts';
+export {generateHtml} from './html';
+export {tryResolveWithExtensions} from './resolve';
+export {buildServiceWorker} from './service-worker';
+export {cleanEmptySourceMaps} from './sourcemaps';

fluxer_app/scripts/build/utils/resolve.ts

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {RESOLVE_EXTENSIONS} from '../config';
+
+export function tryResolveWithExtensions(basePath: string): string | null {
+	if (fs.existsSync(basePath)) {
+		const stat = fs.statSync(basePath);
+		if (stat.isFile()) {
+			return basePath;
+		}
+		if (stat.isDirectory()) {
+			for (const ext of RESOLVE_EXTENSIONS) {
+				const indexPath = path.join(basePath, `index${ext}`);
+				if (fs.existsSync(indexPath)) {
+					return indexPath;
+				}
+			}
+		}
+	}
+
+	for (const ext of RESOLVE_EXTENSIONS) {
+		const withExt = `${basePath}${ext}`;
+		if (fs.existsSync(withExt)) {
+			return withExt;
+		}
+	}
+
+	return null;
+}

fluxer_app/scripts/build/utils/service-worker.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as path from 'node:path';
+import * as esbuild from 'esbuild';
+import {DIST_DIR, SRC_DIR} from '../config';
+
+export async function buildServiceWorker(production: boolean): Promise<void> {
+	await esbuild.build({
+		entryPoints: [path.join(SRC_DIR, 'sw', 'worker.ts')],
+		bundle: true,
+		format: 'iife',
+		outfile: path.join(DIST_DIR, 'sw.js'),
+		minify: production,
+		sourcemap: true,
+		target: 'esnext',
+		define: {
+			__WB_MANIFEST: '[]',
+		},
+	});
+}

fluxer_app/scripts/build/utils/sourcemaps.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function traverseDir(dir: string, callback: (filePath: string) => Promise<void>): Promise<void> {
+	const entries = await fs.promises.readdir(dir, {withFileTypes: true});
+	await Promise.all(
+		entries.map(async (entry) => {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				await traverseDir(entryPath, callback);
+				return;
+			}
+			await callback(entryPath);
+		}),
+	);
+}
+
+export async function cleanEmptySourceMaps(dir: string): Promise<void> {
+	if (!(await fileExists(dir))) {
+		return;
+	}
+
+	await traverseDir(dir, async (filePath) => {
+		if (!filePath.endsWith('.js.map')) {
+			return;
+		}
+
+		let parsed: unknown;
+		try {
+			const raw = await fs.promises.readFile(filePath, 'utf-8');
+			parsed = JSON.parse(raw);
+		} catch {
+			return;
+		}
+
+		if (typeof parsed !== 'object' || parsed === null) {
+			return;
+		}
+
+		const sources = (parsed as {sources?: Array<unknown>}).sources ?? [];
+		if (Array.isArray(sources) && sources.length > 0) {
+			return;
+		}
+
+		await fs.promises.rm(filePath, {force: true});
+
+		const jsPath = filePath.slice(0, -4);
+		if (!(await fileExists(jsPath))) {
+			return;
+		}
+
+		const jsContent = await fs.promises.readFile(jsPath, 'utf-8');
+		const cleaned = jsContent.replace(/(?:\r?\n)?\/\/# sourceMappingURL=.*$/, '');
+		if (cleaned !== jsContent) {
+			await fs.promises.writeFile(jsPath, cleaned);
+		}
+	});
+}