Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
perf(web): deduplicate generated server chunks before Worker packaging (#1159)
Gustavo Ye2d4dc58ce6ff
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 8ffe4c67a..5b19b7c73 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -224,7 +224,7 @@ jobs:- uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0- uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7with:- node-version: 22+ node-version: "22.23.4"cache: pnpm- uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0with:@@ -732,7 +732,7 @@ jobs:- uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0- uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7with:- node-version: 22+ node-version: "22.23.4"cache: pnpm- run: pnpm install --frozen-lockfile- name: Record build artifact identity@@ -819,7 +819,7 @@ jobs:- uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0- uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7with:- node-version: 22+ node-version: "22.23.4"cache: pnpm- run: pnpm install --frozen-lockfile- run: printf 'BETTER_AUTH_SECRET=ci-e2e-ui-secret\nBETTER_AUTH_URL=http://localhost:3000\nENCRYPTION_KEY=ci-e2e-encryption-key-32chars!!\nDEV_WS_DO_URL=http://localhost:3000\nNODE_ENV=development\n' > src/web/.dev.vars@@ -904,7 +904,7 @@ jobs:- uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0- uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7with:- node-version: 22+ node-version: "22.23.4"cache: pnpm- run: pnpm install --frozen-lockfile- run: printf 'BETTER_AUTH_SECRET=ci-e2e-ui-secret\nBETTER_AUTH_URL=http://localhost:3000\nENCRYPTION_KEY=ci-e2e-encryption-key-32chars!!\nDEV_WS_DO_URL=http://localhost:3000\nNODE_ENV=development\n' > src/web/.dev.varsdiff --git a/scripts/ci/changed-scopes.test.ts b/scripts/ci/changed-scopes.test.tsindex 842d2a5ad..16c57c352 100644--- a/scripts/ci/changed-scopes.test.ts+++ b/scripts/ci/changed-scopes.test.ts@@ -441,6 +441,8 @@ describe("canonical execution plan", () => {expect(result.change_class).toBe("blog")expect(result.packages.direct).toEqual(["@alook/web"])expect(result.packages.affected).toEqual(["@alook/agent-driver", "@alook/web"])+ expect(result.suites.unit_build_tasks).toEqual(["@alook/agent-driver#build"])+ expect(result.suites.unit_tasks).not.toContain("@alook/agent-driver#test")expect(result.suites.unit).toEqual(["src/web"])expect(result.coverage.targets).toEqual(["web"])expect(result.coverage.include_roots).toEqual(["src/web/**/*.{ts,tsx,js,jsx}"])@@ -462,6 +464,8 @@ describe("canonical execution plan", () => {expect(result.blog_only).toBe(true)expect(result.packages.direct).toEqual(["@alook/web"])expect(result.packages.affected).toEqual(["@alook/agent-driver", "@alook/web"])+ expect(result.suites.unit_build_tasks).toEqual(["@alook/agent-driver#build"])+ expect(result.suites.unit_tasks).not.toContain("@alook/agent-driver#test")expect(result.suites.unit).toEqual(["src/web"])expect(result.suites.unit_tasks).toContain("@alook/web#test:blog")expect(result.suites.unit_tasks).not.toContain("@alook/web#test")@@ -477,8 +481,11 @@ describe("canonical execution plan", () => {expect(result.auth_only).toBe(true)expect(result.packages.direct).toEqual(["@alook/web"])expect(result.packages.affected).toEqual(["@alook/agent-driver", "@alook/web"])+ expect(result.suites.unit_build_tasks).toEqual(["@alook/agent-driver#build"])+ expect(result.suites.unit_tasks).not.toContain("@alook/agent-driver#test")expect(result.suites.static).toEqual(["@alook/web"])expect(result.suites.unit).toEqual(["src/web"])+ expect(result.coverage.targets).toEqual(["web"])expect(result.suites.integration).toEqual([])expect(result.ui.specs).toEqual([])expect(result.jobs.auth_build).toBe(true)@@ -727,6 +734,9 @@ describe("coverage name-status contract", () => {])expect(result.packages.affected).toEqual(["@alook/agent-driver", "@alook/app", "@alook/web"])+ expect(result.suites.unit_build_tasks).toEqual(["@alook/agent-driver#build"])+ expect(result.suites.unit_tasks).not.toContain("@alook/agent-driver#test")+ expect(result.suites.unit).toEqual(["src/app", "src/web"])expect(result.coverage.targets).toEqual(["web"])expect(result.coverage.required_changed_files).toEqual(["src/web/src/lib/runtime-lookalike.config.ts",diff --git a/scripts/ci/workflow-contract.test.ts b/scripts/ci/workflow-contract.test.tsindex 783800007..32a0b946c 100644--- a/scripts/ci/workflow-contract.test.ts+++ b/scripts/ci/workflow-contract.test.ts@@ -250,6 +250,17 @@ function ciJob(name: string): string {}describe("E2E UI workflow", () => {+ it("uses one exact Node release for shared build production and verification", () => {+ const nodeVersion = (job: string) => ciJob(job).match(/^\s*node-version:\s*["']?([^"'\s]+)["']?\s*$/m)?.[1]+ const version = nodeVersion("ui-e2e-build")+ expect(version).toMatch(/^\d+\.\d+\.\d+$/)+ const verifiers = [...ciWorkflow.matchAll(/^ ([a-z][a-z0-9-]*):$/gm)]+ .map(match => match[1])+ .filter(job => ciJob(job).includes("e2e-build-artifact.mjs verify"))+ expect(verifiers.length).toBeGreaterThan(0)+ for (const job of verifiers) expect(nodeVersion(job), job).toBe(version)+ })+it("isolates resizable-panels upgrades after adopting the latest compatible release", () => {expect(dependabotConfig).toMatch(/^[ ]{6}resizable-panels:\n[ ]{8}patterns:\n[ ]{10}- "react-resizable-panels"$/m)expect(dependabotConfig).toMatch(/^[ ]{8}exclude-patterns:[\s\S]*?^[ ]{10}- "react-resizable-panels"$/m)diff --git a/src/web/scripts/dedupe-server-chunks.test.ts b/src/web/scripts/dedupe-server-chunks.test.tsnew file mode 100644index 000000000..61b938ac3--- /dev/null+++ b/src/web/scripts/dedupe-server-chunks.test.ts@@ -0,0 +1,189 @@+import { createRequire } from "node:module"+import { mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs"+import { tmpdir } from "node:os"+import { dirname, join } from "node:path"+import { afterEach, describe, expect, it } from "vitest"+import { dedupeServerChunks } from "./dedupe-server-chunks"++const roots: string[] = []+const chunk = 'module.exports=[123,context=>{context.exports.value="same"}];\n'++function fixture() {+ const root = mkdtempSync(join(tmpdir(), "alook-server-chunks-"))+ roots.push(root)+ const original = join(root, ".next/server/chunks")+ const standalone = join(root, ".next/standalone/src/web/.next/server/chunks")+ function put(name: string, source = chunk) {+ for (const base of [original, standalone]) {+ const filename = join(base, name)+ mkdirSync(dirname(filename), { recursive: true })+ writeFileSync(filename, source)+ }+ }+ function trace(name: string, files: string[]) {+ const filename = join(root, ".next", name)+ mkdirSync(dirname(filename), { recursive: true })+ writeFileSync(filename, JSON.stringify({ version: 1, files }))+ return filename+ }+ return { root, original, standalone, put, trace }+}++afterEach(() => { for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true }) })++describe("dedupeServerChunks", () => {+ it("preserves all paths and forwards identical chunks to a deterministic canonical file", () => {+ const f = fixture()+ f.put("z.js")+ f.put("a.js")+ const trace = f.trace("server/app/sign-in/page.js.nft.json", ["../../chunks/z.js"])+ const result = dedupeServerChunks(f.root)+ expect(result.aliases).toBe(1)+ expect(result.savedBytes).toBeGreaterThan(0)+ expect(result.updatedTraces).toBe(1)+ expect(readFileSync(join(f.standalone, "a.js"), "utf8")).toBe(chunk)+ expect(readFileSync(join(f.standalone, "z.js"), "utf8")).toBe('module.exports = require("./a.js");\n')+ expect(readFileSync(join(f.original, "z.js"), "utf8")).toBe(chunk)+ expect(JSON.parse(readFileSync(trace, "utf8"))).toEqual({ version: 1, files: ["../../chunks/z.js", "../../chunks/a.js"] })+ expect(dedupeServerChunks(f.root)).toEqual({ aliases: 0, savedBytes: 0, updatedTraces: 0 })+ })++ it("ignores only each file's own trailing source map pointer", () => {+ const f = fixture()+ f.put("a.js", `${chunk}\n//# sourceMappingURL=a.js.map`)+ f.put("b.js", `${chunk}\n//# sourceMappingURL=b.js.map`)+ f.put("c.js", `${chunk}\n//# sourceMappingURL=other.js.map`)+ expect(dedupeServerChunks(f.root).aliases).toBe(1)+ expect(readFileSync(join(f.standalone, "c.js"), "utf8")).toContain("other.js.map")+ })++ it("supports strict IIFE chunks and keeps factory dispatch behavior", () => {+ const f = fixture()+ const source = '(()=>{"use strict";module.exports=[321,context=>{context.exports.n=context.input+1}];})();\n'+ f.put("a.js", source)+ f.put("b.js", source)+ dedupeServerChunks(f.root)+ const require = createRequire(join(f.root, "entry.cjs"))+ const first = require(join(f.standalone, "a.js"))+ const second = require(join(f.standalone, "b.js"))+ expect(second).toBe(first)+ const context = { input: 8, exports: {} }+ second[1](context)+ expect(context.exports).toEqual({ n: 9 })+ })++ it("keeps directories, different bytes, unsupported code and non-JS files separate", () => {+ const f = fixture()+ f.put("a.js")+ f.put("ssr/a.js")+ f.put("different.js", chunk.replace("same", "different"))+ f.put("one.js", 'module.exports={value:"object"};')+ f.put("two.js", 'module.exports={value:"object"};')+ f.put("data.json", chunk)+ f.put("data2.json", chunk)+ f.put("[turbopack]_runtime.js", "globalThis.chunkRuntime = new Map();")+ expect(dedupeServerChunks(f.root).aliases).toBe(0)+ })++ it.each(["__filename", "__dirname", "module.filename", "module.id"])("keeps location-dependent chunks: %s", expression => {+ const f = fixture()+ f.put("a.js", `module.exports=[321,c=>{c.exports.path=${expression}}];`)+ f.put("b.js", `module.exports=[321,c=>{c.exports.path=${expression}}];`)+ expect(dedupeServerChunks(f.root).aliases).toBe(0)+ })++ it("updates top-level traces without dropping metadata or duplicating existing dependencies", () => {+ const f = fixture()+ f.put("a.js")+ f.put("b.js")+ const first = f.trace("next-server.js.nft.json", ["server/chunks/b.js"])+ const second = f.trace("server/app/c/page.js.nft.json", ["../../chunks/b.js", "../../chunks/a.js"])+ expect(dedupeServerChunks(f.root).updatedTraces).toBe(1)+ expect(JSON.parse(readFileSync(first, "utf8")).files).toEqual(["server/chunks/b.js", "server/chunks/a.js"])+ expect(JSON.parse(readFileSync(second, "utf8")).files).toHaveLength(2)+ })++ it("validates traces before changing chunks", () => {+ const f = fixture()+ f.put("a.js")+ f.put("b.js")+ const trace = f.trace("next-server.js.nft.json", [])+ writeFileSync(trace, '{"version":1,"files":[12]}')+ expect(() => dedupeServerChunks(f.root)).toThrow("Invalid Next file trace")+ expect(readFileSync(join(f.standalone, "b.js"), "utf8")).toBe(chunk)+ })++ it("does not follow symlinks or touch the Blog tree", () => {+ const f = fixture()+ f.put("a.js")+ const outside = join(f.root, "outside.js")+ writeFileSync(outside, chunk)+ symlinkSync(outside, join(f.standalone, "linked.js"))+ symlinkSync(dirname(outside), join(f.standalone, "linked-directory"))+ const blog = join(f.root, "blog/.next/standalone/src/web/blog/.next/server/chunks/b.js")+ mkdirSync(dirname(blog), { recursive: true })+ writeFileSync(blog, chunk)+ expect(dedupeServerChunks(f.root).aliases).toBe(0)+ expect(readFileSync(outside, "utf8")).toBe(chunk)+ expect(readFileSync(blog, "utf8")).toBe(chunk)+ })++ it("is a no-op without a standalone build", () => {+ const f = fixture()+ expect(dedupeServerChunks(f.root)).toEqual({ aliases: 0, savedBytes: 0, updatedTraces: 0 })+ })++ it("keeps tiny chunks when forwarding would increase their size", () => {+ const f = fixture()+ f.put("a.js", "module.exports=[1,a=>0];")+ f.put("b.js", "module.exports=[1,a=>0];")+ expect(dedupeServerChunks(f.root).aliases).toBe(0)+ expect(readFileSync(join(f.standalone, "b.js"), "utf8")).toBe("module.exports=[1,a=>0];")+ })++ it.each([+ 'module.exports=[9,(()=>{let count=0;return ()=>++count})()];',+ '(()=>{"use strict";module.exports=[9,()=>++count];let count=0})();',+ 'module.exports=[9,function counter(){return counter.n=(counter.n||0)+1}];',+ ])("preserves independent eager or named-function state: %s", source => {+ const f = fixture()+ f.put("a.js", source)+ f.put("b.js", source)+ expect(dedupeServerChunks(f.root).aliases).toBe(0)+ const require = createRequire(join(f.root, "entry.cjs"))+ expect(require(join(f.standalone, "a.js"))[1]()).toBe(1)+ expect(require(join(f.standalone, "b.js"))[1]()).toBe(1)+ })++ it.each(["module.exports", "exports", "require", "arguments", "this", 'eval("module.exports")'])("does not merge factories capturing their CommonJS wrapper: %s", expression => {+ const f = fixture()+ f.put("a.js", `module.exports=[321,context=>{context.value=${expression}}];`)+ f.put("b.js", `module.exports=[321,context=>{context.value=${expression}}];`)+ expect(dedupeServerChunks(f.root).aliases).toBe(0)+ })++ it("accepts strict factory groups and class-owned context without capturing wrapper state", () => {+ const f = fixture()+ const source = 'module.exports=[[123,context=>{class Example{value=this;method(){return arguments.length}};context.exports={module:Example}}],456,context=>{context.exports="plain"}];'+ f.put("a.js", source)+ f.put("b.js", source)+ expect(dedupeServerChunks(f.root).aliases).toBe(1)+ })++ it.each([+ 'module.exports=[123,context=>{}',+ 'module.exports=[123];',+ 'module.exports=[context=>{}];',+ 'module.exports=[[123]];',+ 'module.exports=[...other];',+ '(function(){module.exports=[123,context=>{}]})()',+ 'module.exports=[123,context=>{return class Example{[this.state](){}}}];',+ 'module.exports=[123,context=>{return class Example{[arguments[0]]=true}}];',+ '(()=>{"use strict";module.exports=[123,context=>{}];sideEffect()})();',+ ])("keeps unsupported or malformed factory containers: %s", source => {+ const f = fixture()+ f.put("a.js", source)+ f.put("b.js", source)+ expect(dedupeServerChunks(f.root).aliases).toBe(0)+ })+})diff --git a/src/web/scripts/dedupe-server-chunks.ts b/src/web/scripts/dedupe-server-chunks.tsnew file mode 100644index 000000000..4d6b76f78--- /dev/null+++ b/src/web/scripts/dedupe-server-chunks.ts@@ -0,0 +1,147 @@+import { existsSync, lstatSync, readFileSync, readdirSync, writeFileSync } from "node:fs"+import { basename, dirname, relative, resolve, sep } from "node:path"+import ts from "typescript"++type Alias = { duplicate: string; canonical: string }++function unwrap(expression: ts.Expression): ts.Expression {+ while (ts.isParenthesizedExpression(expression)) expression = expression.expression+ return expression+}++function hasWrapperCapture(node: ts.Node, ownsContext = false, parent?: ts.Node): boolean {+ if (node.kind === ts.SyntaxKind.ThisKeyword && !ownsContext) return true+ if (ts.isIdentifier(node)) {+ const isProperty = parent && ((ts.isPropertyAccessExpression(parent) && parent.name === node)+ || ((ts.isPropertyAssignment(parent) || ts.isMethodDeclaration(parent) || ts.isGetAccessor(parent)+ || ts.isSetAccessor(parent) || ts.isPropertyDeclaration(parent)) && parent.name === node))+ if (!isProperty && ["module", "exports", "require", "__filename", "__dirname", "eval"].includes(node.text)) return true+ if (node.text === "arguments" && !ownsContext) return true+ }+ const ownsChildContext = ownsContext || (ts.isFunctionLike(node) && !ts.isArrowFunction(node))+ || ts.isPropertyDeclaration(node) || ts.isClassStaticBlockDeclaration(node)+ return ts.forEachChild(node, child => hasWrapperCapture(child,+ ts.isComputedPropertyName(child) ? ownsContext : ownsChildContext, node) || undefined) ?? false+}++function isFactoryArray(array: ts.ArrayLiteralExpression): boolean {+ let index = 0+ if (array.elements[0] && ts.isArrayLiteralExpression(array.elements[0])) {+ if (!isFactoryArray(array.elements[0])) return false+ index+++ }+ while (index < array.elements.length) {+ const start = index+ while (index < array.elements.length && (ts.isNumericLiteral(array.elements[index]) || ts.isStringLiteral(array.elements[index]))) index+++ const factory = array.elements[index]+ if (index === start || !factory || !ts.isArrowFunction(factory) || hasWrapperCapture(factory)) return false+ index+++ }+ return array.elements.length > 0+}++function staticFactoryAssignment(statements: readonly ts.Statement[]): ts.ArrayLiteralExpression | undefined {+ const body = statements.filter(statement => !(ts.isExpressionStatement(statement)+ && ts.isStringLiteral(statement.expression) && statement.expression.text === "use strict"))+ if (body.length !== 1 || !ts.isExpressionStatement(body[0])) return+ const expression = unwrap(body[0].expression)+ if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return+ const left = expression.left+ if (!ts.isPropertyAccessExpression(left) || !ts.isIdentifier(left.expression)+ || left.expression.text !== "module" || left.name.text !== "exports" || !ts.isArrayLiteralExpression(expression.right)) return+ return expression.right+}++function isStaticFactoryChunk(code: string, filename: string): boolean {+ const parsed = ts.createSourceFile(filename, code, ts.ScriptTarget.Latest, false, ts.ScriptKind.JS)+ if ((parsed as ts.SourceFile & { parseDiagnostics: readonly ts.Diagnostic[] }).parseDiagnostics.length) return false+ let array = staticFactoryAssignment(parsed.statements)+ if (!array && parsed.statements.length === 1 && ts.isExpressionStatement(parsed.statements[0])) {+ const call = unwrap(parsed.statements[0].expression)+ if (!ts.isCallExpression(call) || call.arguments.length) return false+ const factory = unwrap(call.expression)+ if (!ts.isArrowFunction(factory) || factory.parameters.length || factory.modifiers?.length || !ts.isBlock(factory.body)) return false+ array = staticFactoryAssignment(factory.body.statements)+ }+ return !!array && isFactoryArray(array)+}++function filesIn(directory: string): string[] {+ if (!existsSync(directory) || !lstatSync(directory).isDirectory()) return []+ return readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name, "en"))+ .flatMap(entry => entry.isDirectory() ? filesIn(resolve(directory, entry.name))+ : entry.isFile() ? [resolve(directory, entry.name)] : [])+}++function executableChunk(source: string, filename: string): string | undefined {+ const marker = "\n//# sourceMappingURL="+ const offset = source.lastIndexOf(marker)+ const code = offset >= 0 && source.slice(offset + marker.length).trimEnd() === `${basename(filename)}.map`+ ? source.slice(0, offset) : source+ if (!code.includes("module.exports")) return+ if (!isStaticFactoryChunk(code, filename)) return+ return code+}++function traceUpdates(nextRoot: string, aliases: Alias[]): Map<string, string> {+ const aliasesBySource = new Map(aliases.map(alias => [alias.duplicate, alias.canonical]))+ const changes = new Map<string, string>()+ const traces = filesIn(resolve(nextRoot, "server")).filter(filename => filename.endsWith(".nft.json"))+ for (const name of readdirSync(nextRoot)) {+ const filename = resolve(nextRoot, name)+ if (name.endsWith(".nft.json") && lstatSync(filename).isFile()) traces.push(filename)+ }+ for (const filename of traces) {+ const trace = JSON.parse(readFileSync(filename, "utf8")) as { files?: unknown }+ if (!Array.isArray(trace.files) || !trace.files.every((file): file is string => typeof file === "string")) {+ throw new Error(`Invalid Next file trace: ${filename}`)+ }+ const files = new Set(trace.files)+ let changed = false+ for (const file of trace.files) {+ const canonical = aliasesBySource.get(resolve(dirname(filename), file))+ if (!canonical) continue+ const dependency = relative(dirname(filename), canonical).split(sep).join("/")+ if (!files.has(dependency)) {+ files.add(dependency)+ changed = true+ }+ }+ if (changed) changes.set(filename, JSON.stringify({ ...trace, files: [...files] }))+ }+ return changes+}++export function dedupeServerChunks(webRoot: string): { aliases: number; savedBytes: number; updatedTraces: number } {+ const nextRoot = resolve(webRoot, ".next")+ const standaloneNext = resolve(nextRoot, "standalone/src/web/.next")+ const chunksRoot = resolve(standaloneNext, "server/chunks")+ const canonicalByCode = new Map<string, string>()+ const writes = new Map<string, string>()+ const aliases: Alias[] = []+ let savedBytes = 0+ for (const filename of filesIn(chunksRoot)) {+ if (!filename.endsWith(".js")) continue+ const source = readFileSync(filename, "utf8")+ const code = executableChunk(source, filename)+ if (!code) continue+ const key = `${dirname(filename)}\0${code}`+ const canonical = canonicalByCode.get(key)+ if (!canonical) {+ canonicalByCode.set(key, filename)+ continue+ }+ const replacement = `module.exports = require(${JSON.stringify(`./${basename(canonical)}`)});\n`+ if (Buffer.byteLength(replacement) >= Buffer.byteLength(source)) continue+ writes.set(filename, replacement)+ savedBytes += Buffer.byteLength(source) - Buffer.byteLength(replacement)+ aliases.push({+ duplicate: resolve(nextRoot, relative(standaloneNext, filename)),+ canonical: resolve(nextRoot, relative(standaloneNext, canonical)),+ })+ }+ const traces = aliases.length ? traceUpdates(nextRoot, aliases) : new Map<string, string>()+ for (const [filename, source] of writes) writeFileSync(filename, source)+ for (const [filename, source] of traces) writeFileSync(filename, source)+ return { aliases: aliases.length, savedBytes, updatedTraces: traces.size }+}diff --git a/src/web/scripts/stage-service-worker.test.ts b/src/web/scripts/stage-service-worker.test.tsindex ff36e024e..e8d27a043 100644--- a/src/web/scripts/stage-service-worker.test.ts+++ b/src/web/scripts/stage-service-worker.test.ts@@ -28,6 +28,17 @@ function fixture() {return root}describe("complete build shell and worker staging", () => {+ it("deduplicates standalone chunks through the normal post-build staging entry", async () => {+ const root = fixture()+ const chunks = resolve(root, ".next/standalone/src/web/.next/server/chunks")+ mkdirSync(chunks, { recursive: true })+ const source = 'module.exports=[123,context=>{context.exports.value="same"}];\n'+ writeFileSync(resolve(chunks, "a.js"), source)+ writeFileSync(resolve(chunks, "b.js"), source)+ await stageServiceWorker(root)+ expect(readFileSync(resolve(chunks, "a.js"), "utf8")).toBe(source)+ expect(readFileSync(resolve(chunks, "b.js"), "utf8")).toBe('module.exports = require("./a.js");\n')+ })it("builds a classic worker from explicit public asset globs", async () => {await stageServiceWorker(fixture())const options = mocks.options as RouteOptions | nulldiff --git a/src/web/scripts/stage-service-worker.ts b/src/web/scripts/stage-service-worker.tsindex 8162b9623..b2e897554 100644--- a/src/web/scripts/stage-service-worker.ts+++ b/src/web/scripts/stage-service-worker.ts@@ -5,6 +5,7 @@ import { resolve } from "node:path"import { fileURLToPath } from "node:url"import { isPublicAssetPath } from "../src/lib/service-worker/public-cache"import { communityShellDirectory, communityShellHash } from "../src/lib/service-worker/community-shell"+import { dedupeServerChunks } from "./dedupe-server-chunks"export function stageCommunityShell(webRoot: string): string {const prerender = JSON.parse(readFileSync(resolve(webRoot, ".next/prerender-manifest.json"), "utf8")) as { routes: Record<string, unknown> }@@ -54,6 +55,7 @@ export async function stageServiceWorker(webRoot: string): Promise<void> {const bytes = Buffer.from(await response.arrayBuffer())if (!bytes.length || !bytes.includes(shellUrl)) throw new Error("Generated service worker is missing the current community shell")writeFileSync(resolve(webRoot, "public/sw.js"), bytes)+ dedupeServerChunks(webRoot)}if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {diff --git a/src/web/src/test/e2e-ui/55-reaction-backward-reading.spec.ts b/src/web/src/test/e2e-ui/55-reaction-backward-reading.spec.tsindex eed3cb500..6b4160238 100644--- a/src/web/src/test/e2e-ui/55-reaction-backward-reading.spec.ts+++ b/src/web/src/test/e2e-ui/55-reaction-backward-reading.spec.ts@@ -27,6 +27,7 @@ test("measured reaction updates above the fold preserve reading during repeatedawait waitForCommittedGeometry(scroller)await scroller.evaluate(element => { element.scrollTop = 0; element.dispatchEvent(new Event("scroll")) })await expect(page.getByTestId(tid.message(messageId))).toHaveCount(1)+ await waitForCommittedGeometry(scroller)await scroller.evaluate((element, id) => {const row = element.querySelector<HTMLElement>(`[data-msg-id="${id}"]`)if (!row) throw new Error("The measured reaction message is required")