Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

perf(web): deduplicate generated server chunks before Worker packaging (#1159)

Gustavo Ye2d4dc58ce6ff
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 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 # v7
with:
- node-version: 22
+ node-version: "22.23.4"
cache: pnpm
- uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
with:
@@ -732,7 +732,7 @@ jobs:
- uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0
- uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7
with:
- 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 # v7
with:
- 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 # v7
with:
- 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
diff --git a/scripts/ci/changed-scopes.test.ts b/scripts/ci/changed-scopes.test.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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 | null
diff --git a/src/web/scripts/stage-service-worker.ts b/src/web/scripts/stage-service-worker.ts
index 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.ts
index 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 repeated
await 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")