Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(web): migrate server rail drag and drop to PDD (#588)

Gener9d4a7c2a7628
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 589901b0a..045d2b774 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -283,6 +283,18 @@ importers:
'@alook/shared':
specifier: workspace:*
version: link:../shared
+ '@atlaskit/pragmatic-drag-and-drop':
+ specifier: 3.0.0
+ version: 3.0.0
+ '@atlaskit/pragmatic-drag-and-drop-auto-scroll':
+ specifier: 3.1.0
+ version: 3.1.0
+ '@atlaskit/pragmatic-drag-and-drop-hitbox':
+ specifier: 2.1.0
+ version: 2.1.0
+ '@atlaskit/pragmatic-drag-and-drop-live-region':
+ specifier: 2.0.0
+ version: 2.0.0
'@base-ui/react':
specifier: ^1.7.0
@@ -753,6 +765,18 @@ packages:
'@astrojs/[email protected]':
resolution: {integrity: sha512-eouss7G8ygdZqHuke033VMcVw5HTZUu+PXd/h06DGDUg/jt5btPYPqh66ENWw/mU78rBrf/oeC4oqoBwMtDMNA==}
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-YfxLci5SA2MwdJKIVpnEZfbiOGWQIQnD1NvUgqFq96v33PGVWQy13k07KxeSkR/M8E6VBiYRoglelyCdRmyyBQ==}
+
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-88krJVd1OcPHy0EFcJx0CjT1AOTB/1AneVvDWOhU4FH6NYDgTNF69euj8GUE07r0KK3L+9V77MKQhaOtwq2mXA==}
+
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-GrlZdZQSw4yegSrU8EDcaO6IBDEAYbSMgv3tTTfkbdmOjpEnwXmNGHe7CiA3GR9LgUNiKpERR9tlfa+viXIGvA==}
+
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-EEKBELv757wrvhMHBAoFcXjfzGZ4Y2FJ2xnSsWovsOKywkN1Q4IWRH52hQpPmJnATLcmO9viVhoXWSXFBLKSLQ==}
+
'@aws-crypto/[email protected]':
resolution: {integrity: sha512-OH6lveCFfcDjX4dbAvCFSYUjJZjDr/3XJ3xHtjn3Oj5b9RjojQo8npoLeA/bNwkOkrSQ0wgrHzXk4tDRxGKJeg==}
@@ -4760,6 +4784,9 @@ packages:
resolution: {integrity: sha512-dq9AtApgg5PGFtBzPFSBl3HZQjHok5gaQCM6zh2Yk0aSmDCs1CbnVI8/HgASQkNKsWFpseIO9beg5xxpYhbIfA==}
engines: {node: 20.x || 22.x || 23.x || 24.x || 25.x || 26.x}
+ resolution: {integrity: sha512-PJvH288AWQhKs2v9zyfYdPzlPqf5bXbGMmhmUIY9x4dAUGIWgomO771oBQNwJnMQSnUIXhKu6sgzpBRXTlvb8Q==}
+
resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
@@ -8065,6 +8092,9 @@ packages:
resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+ resolution: {integrity: sha512-tQkJl2GRWh83ui2DiPTJz9wEiMN20syf+5oKfB03yYP7ioZcJwsIK8FjrtLwH1m7C7e+Tt2yYBlrOpdT+dyeIQ==}
+
resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
engines: {node: '>= 0.6'}
@@ -9581,6 +9611,26 @@ snapshots:
'@astrojs/[email protected]': {}
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@atlaskit/pragmatic-drag-and-drop': 3.0.0
+ '@babel/runtime': 7.29.7
+
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@atlaskit/pragmatic-drag-and-drop': 3.0.0
+ '@babel/runtime': 7.29.7
+
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@babel/runtime': 7.29.7
+
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@babel/runtime': 7.29.7
+ bind-event-listener: 3.0.0
+ raf-schd: 4.0.3
+
'@aws-crypto/[email protected]':
dependencies:
'@aws-crypto/supports-web-crypto': 5.2.0
@@ -13592,6 +13642,8 @@ snapshots:
bindings: 1.5.0
prebuild-install: 7.1.3
+
dependencies:
file-uri-to-path: 1.0.0
@@ -17720,6 +17772,8 @@ snapshots:
+
diff --git a/scripts/ci/e2e-shards.mjs b/scripts/ci/e2e-shards.mjs
index 3b40dea23..6c8dc4cc3 100644
--- a/scripts/ci/e2e-shards.mjs
+++ b/scripts/ci/e2e-shards.mjs
@@ -47,6 +47,7 @@ export const SPEC_SECONDS = {
"34-inbox-read-race.spec.ts": 42,
"35-channel-ref-directory-states.spec.ts": 60,
"36-server-switch-pending-checkpoint.spec.ts": 60,
+ "37-server-rail-pdd.spec.ts": 10,
}
function walk(directory) {
diff --git a/scripts/ci/e2e-shards.test.ts b/scripts/ci/e2e-shards.test.ts
index 9ab06ac44..c7a9b316b 100644
--- a/scripts/ci/e2e-shards.test.ts
+++ b/scripts/ci/e2e-shards.test.ts
@@ -70,7 +70,7 @@ describe("planE2eShards", () => {
expect(first).toHaveLength(E2E_SHARD_COUNT)
expect([...assigned].sort()).toEqual(specs)
expect(new Set(assigned).size).toBe(specs.length)
- expect(totals.sort((left, right) => left - right)).toEqual([301, 302, 302, 303, 304])
+ expect(totals.sort((left, right) => left - right)).toEqual([302, 303, 305, 305, 307])
expect(Math.max(...totals) / Math.min(...totals)).toBeLessThanOrEqual(1.15)
})
diff --git a/spikes/server-rail-pdd/.gitignore b/spikes/server-rail-pdd/.gitignore
new file mode 100644
index 000000000..6562ea30d
--- /dev/null
+++ b/spikes/server-rail-pdd/.gitignore
@@ -0,0 +1,4 @@
+dist/
+node_modules/
+playwright-report/
+test-results/
diff --git a/spikes/server-rail-pdd/RESULTS.md b/spikes/server-rail-pdd/RESULTS.md
new file mode 100644
index 000000000..51042a460
--- /dev/null
+++ b/spikes/server-rail-pdd/RESULTS.md
@@ -0,0 +1,96 @@
+# Server Rail PDD Spike Results
+
+## Decision
+
+**Go for a production migration checkpoint, with native PDD limited to pointer drag and the explicit Move menu retained for touch and keyboard.** The normalized reducer and list-item hitbox contract removed canonical drag-over mutation, every valid drop emitted one optimistic commit, and the tested cancel paths emitted no persistence batch.
+
+This is not approval to land product code yet. Review of the four visual and interaction details remains the next gate. If native long-press touch dragging is a hard product requirement, the result is **No-go for PDD-only touch**: Chromium mobile emulation proves that PDD leaves swipe and tap alone, but it does not prove a reliable native long-press drag gesture. That requirement should keep a dedicated touch sensor or use the explicit Move action.
+
+## Frozen scope
+
+- Baseline: fresh main `61efa2343291875e08b96dd522869d9ccbf48713` (the production rail implementation files are byte-unchanged from the original `b5bc5fa854784ff8d77a7fcdb04b0edcb618629c` spike baseline)
+- Branch: `spike/server-rail-pdd-fresh-main`
+- Product files changed: none
+- Fixture: 18 servers, 2 folders, 460 px desktop rail viewport, 520 px mobile rail viewport
+- PDD surface: core element adapter, list-item hitbox, element auto-scroll, and live region only
+- Excluded: channel-sidebar DnD, API/schema changes, server navigation, and production styling
+
+## Browser evidence
+
+Desktop Chromium passed these real-input journeys:
+
+- A pointer down, 2 px sub-threshold move, and release incremented navigation once and produced zero drag commits.
+- Bottom-quarter pointer drop reordered `a` after `b`; one optimistic commit and one persistence batch were recorded.
+- Center pointer drop combined `a` and `b`; the persistence planner emitted one `create-folder` command.
+- Drag-over changed only the preview instruction and indicator. Canonical state stayed byte-for-byte equal until drop.
+- Leaving a collapsed folder after 200 ms prevented expansion; a continuous 550 ms combine hover expanded it.
+- Escape and release outside all targets each restored the drag-start snapshot with zero commit and zero persistence batch.
+- Dragging expanded folder `one` temporarily hid its children; cancel restored them.
+- A 260 px wheel gesture scrolled natively. Holding a drag at the bottom edge increased `scrollTop` while canonical state stayed fixed.
+- A forced persistence rejection rolled back the exact snapshot after one optimistic commit.
+- The Move menu produced the same cross-folder reducer result, announced the literal outcome through the PDD live region, and restored focus to the moved server.
+
+Mobile-emulated Chromium passed:
+
+- A touch sequence of eight 18 px vertical moves scrolled the rail from a server row with zero click and zero drag commit.
+- A short touch tap invoked the server action exactly once with zero drag commit.
+- The explicit Move action moved `a` into folder `two` with one persistence batch.
+
+WebKit was not run because no Playwright WebKit browser is installed locally. Physical iOS and Android remain required only if native long-press drag is reconsidered; the recommended contract does not depend on it.
+
+The fresh-main rerun caught one real POC contract defect: sticky row drop targets retained the last folder instruction after the pointer left the rail, so an outside release could commit instead of cancel. The POC now uses non-sticky row targets. The exact cancel/hover journey then passed five consecutive focused repeats and the complete matrix; auto-scroll and valid drop targeting remained green.
+
+## Reducer and persistence evidence
+
+Eleven Vitest cases cover top-level before/after reorder, folder reorder, same-folder reorder, rail-to-folder, folder-to-rail, folder-to-folder, server combine, the 10-folder limit, duplicate/invalid state rejection, empty-folder deletion, zero-write no-ops, minimal command planning, and accessible labels.
+
+The reducer owns the only canonical transition. PDD drag-over stores one `RailInstruction` preview and applies no state or persistence mutation. The final drop uses the immutable start snapshot, applies one reducer transition, computes the command set, and can restore that exact snapshot after rejection.
+
+The platform's native drag API does not distinguish Escape from another no-target termination. The integration intentionally treats every final drop with no valid innermost instruction as the same zero-write cancel outcome.
+
+## Dependency and bundle surface
+
+The isolated production build contains 81 transformed modules:
+
+- HTML: 0.64 kB raw / 0.39 kB gzip
+- CSS: 2.22 kB raw / 0.98 kB gzip
+- JavaScript including the fixture: 47.01 kB raw / 13.56 kB gzip
+
+The runtime has no React or tree-wrapper dependency. Candidate exact packages are:
+
+- `@atlaskit/[email protected]`
+- `@atlaskit/[email protected]`
+- `@atlaskit/[email protected]`
+- `@atlaskit/[email protected]`
+
+All four exact versions remained the current registry releases during the fresh-main rerun.
+
+## Verification
+
+- `pnpm typecheck` — pass
+- `pnpm test` — 11 passed
+- `pnpm test:browser` — 5 passed, 5 expected project skips
+- focused hover/cancel stability rerun — 5 passed across five consecutive repeats
+- `pnpm build` — pass
+- `git diff --check` — pass
+- POC implementation/config manifest SHA256 (excluding this report and generated evidence) — `e73d3b1a3a6ae3cadfd79ff9cb7d8673b24de00b748e47d2bbd518d8fc1edb40`
+- Product diff relative to fresh main — empty; port 4177 free after teardown
+
+The desktop combine-target and mobile Move-menu screenshots were visually inspected. They prove the interaction states are visible and usable in the fixture, but they are not production-design approval: the combine border strength, insertion-line treatment, 500 ms expansion feedback, and compact mobile Move flow remain the four explicit design-review items.
+
+## Production recommendation
+
+Proceed only after the design checkpoint. Keep the normalized state and persistence planner framework-independent. Use PDD list-item instructions for desktop pointer preview, commit once in the final monitor drop, and keep the existing server-folder API boundaries. Touch and keyboard should use the same reducer through the Move menu. Channel-sidebar dnd-kit remains untouched.
+
+The proposed production file boundary is:
+
+- `src/web/package.json`
+- `pnpm-lock.yaml`
+- `src/web/src/components/community/shell/server-rail.tsx`
+- `src/web/src/components/community/shell/use-rail-order.ts`
+- `src/web/src/components/community/shell/use-rail-order.test.ts`
+- `src/web/src/components/community/shell/server-rail-actions.ts`
+- `src/web/src/components/community/shell/server-rail-actions.test.ts`
+- `src/web/src/test/e2e-ui/server-rail-dnd.spec.ts`
+
+No production file should be touched until the insertion line, combine border, 500 ms expansion timing, and touch feedback receive their pending design review.
diff --git a/spikes/server-rail-pdd/evidence/.gitkeep b/spikes/server-rail-pdd/evidence/.gitkeep
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/spikes/server-rail-pdd/evidence/.gitkeep
@@ -0,0 +1 @@
+
diff --git a/spikes/server-rail-pdd/evidence/desktop-hover-combine.png b/spikes/server-rail-pdd/evidence/desktop-hover-combine.png
new file mode 100644
index 000000000..3c738bca1
Binary files /dev/null and b/spikes/server-rail-pdd/evidence/desktop-hover-combine.png differ
diff --git a/spikes/server-rail-pdd/evidence/mobile-move-menu.png b/spikes/server-rail-pdd/evidence/mobile-move-menu.png
new file mode 100644
index 000000000..b17333edd
Binary files /dev/null and b/spikes/server-rail-pdd/evidence/mobile-move-menu.png differ
diff --git a/spikes/server-rail-pdd/index.html b/spikes/server-rail-pdd/index.html
new file mode 100644
index 000000000..b269dfbcb
--- /dev/null
+++ b/spikes/server-rail-pdd/index.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+ <head>
+ <meta charset="UTF-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+ <title>Server rail PDD spike</title>
+ </head>
+ <body>
+ <main>
+ <h1>Server rail PDD spike</h1>
+ <p id="instructions">Drag to preview and drop once. Use each item’s Move button for the accessible equivalent.</p>
+ <div id="app"></div>
+ <pre id="events" aria-label="Event log"></pre>
+ </main>
+ <script type="module" src="/src/main.ts"></script>
+ </body>
+</html>
diff --git a/spikes/server-rail-pdd/package.json b/spikes/server-rail-pdd/package.json
new file mode 100644
index 000000000..9f03d037a
--- /dev/null
+++ b/spikes/server-rail-pdd/package.json
@@ -0,0 +1,25 @@
+{
+ "name": "@alook/server-rail-pdd-spike",
+ "private": true,
+ "type": "module",
+ "scripts": {
+ "build": "vite build",
+ "dev": "vite --host 127.0.0.1 --port 4177 --strictPort",
+ "test": "vitest run",
+ "test:browser": "playwright test",
+ "typecheck": "tsc --noEmit"
+ },
+ "dependencies": {
+ "@atlaskit/pragmatic-drag-and-drop": "3.0.0",
+ "@atlaskit/pragmatic-drag-and-drop-auto-scroll": "3.1.0",
+ "@atlaskit/pragmatic-drag-and-drop-hitbox": "2.1.0",
+ "@atlaskit/pragmatic-drag-and-drop-live-region": "2.0.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "1.62.1",
+ "@types/node": "25.9.4",
+ "typescript": "6.0.3",
+ "vite": "8.2.2",
+ "vitest": "4.1.10"
+ }
+}
diff --git a/spikes/server-rail-pdd/playwright.config.ts b/spikes/server-rail-pdd/playwright.config.ts
new file mode 100644
index 000000000..53d9355c7
--- /dev/null
+++ b/spikes/server-rail-pdd/playwright.config.ts
@@ -0,0 +1,19 @@
+import { defineConfig, devices } from "@playwright/test"
+
+export default defineConfig({
+ testDir: "./tests",
+ timeout: 30_000,
+ use: {
+ baseURL: "http://127.0.0.1:4177",
+ trace: "retain-on-failure",
+ },
+ projects: [
+ { name: "desktop-chromium", use: { ...devices["Desktop Chrome"] } },
+ { name: "mobile-chromium", use: { ...devices["Pixel 7"] } },
+ ],
+ webServer: {
+ command: "pnpm dev",
+ url: "http://127.0.0.1:4177",
+ reuseExistingServer: false,
+ },
+})
diff --git a/spikes/server-rail-pdd/pnpm-lock.yaml b/spikes/server-rail-pdd/pnpm-lock.yaml
new file mode 100644
index 000000000..bcaadcced
--- /dev/null
+++ b/spikes/server-rail-pdd/pnpm-lock.yaml
@@ -0,0 +1,829 @@
+lockfileVersion: '9.0'
+
+settings:
+ autoInstallPeers: true
+ excludeLinksFromLockfile: false
+
+importers:
+
+ .:
+ dependencies:
+ '@atlaskit/pragmatic-drag-and-drop':
+ specifier: 3.0.0
+ version: 3.0.0
+ '@atlaskit/pragmatic-drag-and-drop-auto-scroll':
+ specifier: 3.1.0
+ version: 3.1.0
+ '@atlaskit/pragmatic-drag-and-drop-hitbox':
+ specifier: 2.1.0
+ version: 2.1.0
+ '@atlaskit/pragmatic-drag-and-drop-live-region':
+ specifier: 2.0.0
+ version: 2.0.0
+ devDependencies:
+ '@playwright/test':
+ specifier: 1.62.1
+ version: 1.62.1
+ '@types/node':
+ specifier: 25.9.4
+ version: 25.9.4
+ typescript:
+ specifier: 6.0.3
+ version: 6.0.3
+ vite:
+ specifier: 8.2.2
+ version: 8.2.2(@types/[email protected])
+ vitest:
+ specifier: 4.1.10
+ version: 4.1.10(@types/[email protected])([email protected](@types/[email protected]))
+
+packages:
+
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-YfxLci5SA2MwdJKIVpnEZfbiOGWQIQnD1NvUgqFq96v33PGVWQy13k07KxeSkR/M8E6VBiYRoglelyCdRmyyBQ==}
+
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-88krJVd1OcPHy0EFcJx0CjT1AOTB/1AneVvDWOhU4FH6NYDgTNF69euj8GUE07r0KK3L+9V77MKQhaOtwq2mXA==}
+
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-GrlZdZQSw4yegSrU8EDcaO6IBDEAYbSMgv3tTTfkbdmOjpEnwXmNGHe7CiA3GR9LgUNiKpERR9tlfa+viXIGvA==}
+
+ '@atlaskit/[email protected]':
+ resolution: {integrity: sha512-EEKBELv757wrvhMHBAoFcXjfzGZ4Y2FJ2xnSsWovsOKywkN1Q4IWRH52hQpPmJnATLcmO9viVhoXWSXFBLKSLQ==}
+
+ '@babel/[email protected]':
+ resolution: {integrity: sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==}
+ engines: {node: '>=6.9.0'}
+
+ '@jridgewell/[email protected]':
+ resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+ '@oxc-project/[email protected]':
+ resolution: {integrity: sha512-IJ3s6ltHLp45S0bh7phkX+gJO7A1Wuz2EaqpAhb8WjqDwbzMiWKHhyyT42tskaWjEYXtHtVCPpnBJVT9+dcRLg==}
+
+ '@playwright/[email protected]':
+ resolution: {integrity: sha512-DTcUc8qii+cpHvtOwggMtBRMjKZHXYWdw8syRYu2vtzuq4Wxphqq4NfCs5Zt44L6mA8rfDfj+PHnxFc/FeK6mQ==}
+ engines: {node: '>=20'}
+ hasBin: true
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-b+jTcARdTiFLI6jB4a5XjTm0RWd6KcRfQj/I2356fxUZemiho9zQLxo0RtCuMDAyKcLo6cEltkgbQp6d1+sjjQ==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm]
+ os: [android]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-lkWU8ZJaRk9q3CIEY1Tc7vIFALp3Xw5NfGJo2hQg5oIqNgxWi1zI+IiDEK3r70BF5Dzol1tcXsnzsRc8NLhG+Q==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [android]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-dgR56NYnvAszm7Ob1B2/Vn0e8bUQYZH2UjVaMMtMVOCKFSfjhfLmuA/9+O+F+ajUdG6B/bSssrKW6JJYASa8jA==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [darwin]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-vpVxFvUCFioJqug7OTvqptkc4yb8UX0AwfDmJpaR/0sWz+BUmqSVAf7c8JkUgnN8YLspb4a/N6NhTyMAmdyQ7Q==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [darwin]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-h1wG6Y6K3JlRswxsI64qQJqBAy4vrLuHgRbc8CZMGSWTOFRY6ghMApM1NKzB2I0n5xV1fjkE18SuVl2QpLeNpA==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [freebsd]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-tbCiqub0q2MVWJKgF5PoAlNWCtQydiOYSLIkd8sByqK/6MMYLJRcSXSYodqYtd0O+Fw7QaVmKKlS4oL94YRZ0w==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-oxK9+baEBPhZG5HB4URY+uU04zJWeZlH6Tb9rB5DK4DF9XR1uXNLXt5Q5ZsugTKayNCNLhkcwz/ye74hRI98dg==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [linux]
+ libc: [glibc]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-muWCk27FVBEZtv0MsK8gnfSmgczA8KQ0uRVJbTABKhkRfQc38aUrcb7fhi3BNiyseFmgcRsoMfQsSNJ+DbZdSw==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [linux]
+ libc: [musl]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-eWDoSfU7Co2qj3vgB3Dt4lj1mG6CoWbcJQkRMP3XJplyCMtuaq3LHvPFjS9QIPvMGWVadJC04Xiy0IdcVPtnwQ==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [ppc64]
+ os: [linux]
+ libc: [glibc]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-2bWNjRSIayvupRKxXUY2tWG9fYdoUlTqWywHRvE8Eq3GvuQ+f2HeIkve697fIt+IQs/PV8yFsdWuhp1aJ1PdnA==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [s390x]
+ os: [linux]
+ libc: [glibc]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-KekI0gS0wLxe1UBSQSjenBVwou/JkcQPDzBPICGZjxUv9k3RteHDPBQaiOicZUFKRIH2wKEimGwVpnJsbPzu7w==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [linux]
+ libc: [glibc]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-TvtPnfVr+HtyGiDmPK4VWmlNm7QhNNAcK5Q9A7aOXsI8545yCyaoMaicXrFZ72JzeYjaUVk7yT243zT0jzjFKQ==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [linux]
+ libc: [musl]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-iOo0VEay2XFhaCcH0sps5XIimkSuOnNaZrf6+ZkoSOQBJPKNU48RkmJv0/lSpipexu5P+ouFgafe5IGr/DiQfg==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [openharmony]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-y5NTmmasMS455JlOCO4ZM9krIchv3Mvm1crL1iUPGOPgEzSkves9n0SdC5Sjz6+qWDFhd8/JpfWMH8NSWNHe+A==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [win32]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-np8iZSLfXlAD4kWhiyq/u0Yt8oZDtRQ8lGhQaCXo2rl37KNjeU0GjJuwr4P3oeZ++ROfofsKNBqR5LTO8aXyWQ==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [win32]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==}
+
+ '@standard-schema/[email protected]':
+ resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+ '@types/[email protected]':
+ resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
+
+ '@types/[email protected]':
+ resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
+
+ '@types/[email protected]':
+ resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
+
+ '@types/[email protected]':
+ resolution: {integrity: sha512-dszCsrKb5U7ZsVZBWiHFklTloVl0mSEnWH/iZXfZUlI4rzCUnsvGmgqfuVRHL54ugE7/wRuxEIXRa2iMZ+BG6g==}
+
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==}
+
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==}
+ peerDependencies:
+ msw: ^2.4.9
+ vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+ peerDependenciesMeta:
+ msw:
+ optional: true
+ vite:
+ optional: true
+
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==}
+
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==}
+
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==}
+
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==}
+
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==}
+
+ resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+ engines: {node: '>=12'}
+
+ resolution: {integrity: sha512-PJvH288AWQhKs2v9zyfYdPzlPqf5bXbGMmhmUIY9x4dAUGIWgomO771oBQNwJnMQSnUIXhKu6sgzpBRXTlvb8Q==}
+
+ resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
+ engines: {node: '>=18'}
+
+ resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+ resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+ engines: {node: '>=8'}
+
+ resolution: {integrity: sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==}
+
+ resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+ resolution: {integrity: sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==}
+ engines: {node: '>=12.0.0'}
+
+ resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+ engines: {node: '>=12.0.0'}
+ peerDependencies:
+ picomatch: ^3 || ^4
+ peerDependenciesMeta:
+ picomatch:
+ optional: true
+
+ resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
+ engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+ os: [darwin]
+
+ resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+ engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+ os: [darwin]
+
+ resolution: {integrity: sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [android]
+
+ resolution: {integrity: sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [darwin]
+
+ resolution: {integrity: sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [darwin]
+
+ resolution: {integrity: sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [freebsd]
+
+ resolution: {integrity: sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm]
+ os: [linux]
+
+ resolution: {integrity: sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [linux]
+ libc: [glibc]
+
+ resolution: {integrity: sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [linux]
+ libc: [musl]
+
+ resolution: {integrity: sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [linux]
+ libc: [glibc]
+
+ resolution: {integrity: sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [linux]
+ libc: [musl]
+
+ resolution: {integrity: sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [win32]
+
+ resolution: {integrity: sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [win32]
+
+ resolution: {integrity: sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==}
+ engines: {node: '>= 12.0.0'}
+
+ resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+ resolution: {integrity: sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==}
+ engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+ hasBin: true
+
+ resolution: {integrity: sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA==}
+ engines: {node: '>=12.20.0'}
+
+ resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
+
+ resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+ resolution: {integrity: sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==}
+ engines: {node: '>=12'}
+
+ resolution: {integrity: sha512-wPYSwEBJY9GHraISXqyqtx0na0LpO3XEX7jNDhntbex7tzUS7kLnZsOlFruFJB4Hi/rhDMjXGqHewDZ68nYZVw==}
+ engines: {node: '>=20'}
+ hasBin: true
+
+ resolution: {integrity: sha512-0M+L3LAD8/nm554LOla9Ayx0j0tmFZ0FBcoQ7F1VuVHpM/XpiC8RcDzBQB8W5+hA8L22THxELzeF+2WcUzvcLg==}
+ engines: {node: '>=20'}
+ hasBin: true
+
+ resolution: {integrity: sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==}
+ engines: {node: ^10 || ^12 || >=14}
+
+ resolution: {integrity: sha512-tQkJl2GRWh83ui2DiPTJz9wEiMN20syf+5oKfB03yYP7ioZcJwsIK8FjrtLwH1m7C7e+Tt2yYBlrOpdT+dyeIQ==}
+
+ resolution: {integrity: sha512-vMM4q3aixf46GiF1Kok8jDPFsEpXgFWGjUHXNkNHNm+Y2adXAG2dbX91jkti3i0ZRsOlcmbuzAz1poObSHCmUA==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ hasBin: true
+
+ resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
+ resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+ engines: {node: '>=0.10.0'}
+
+ resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
+ resolution: {integrity: sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==}
+
+ resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
+ resolution: {integrity: sha512-QKAl9m8gWWGHV8jZcPeym6j+XULi6tOf1mT83WYJ4Lk2ytW/uwAWkrP0uFsdoYMdueVJ0qs26wZ+23xeB4ibNQ==}
+ engines: {node: '>=18'}
+
+ resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
+ engines: {node: '>=12.0.0'}
+
+ resolution: {integrity: sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==}
+ engines: {node: '>=14.0.0'}
+
+ resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
+ engines: {node: '>=14.17'}
+ hasBin: true
+
+ resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==}
+
+ resolution: {integrity: sha512-cFKLV/PRgAUlIRm5WjMjJ86jrftzpqcgH+Us+DS8mI3CDNiH30Whrz8uHL3+MOLPAgqbMBAqWdAHAphOAM+z/Q==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ hasBin: true
+ peerDependencies:
+ '@types/node': ^20.19.0 || >=22.12.0
+ '@vitejs/devtools': ^0.4.0 || ^0.5.0
+ esbuild: ^0.27.0 || ^0.28.0
+ jiti: '>=1.21.0'
+ less: ^4.0.0
+ sass: ^1.70.0
+ sass-embedded: ^1.70.0
+ stylus: '>=0.54.8'
+ sugarss: ^5.0.0
+ terser: ^5.16.0
+ tsx: ^4.8.1
+ yaml: ^2.4.2
+ peerDependenciesMeta:
+ '@types/node':
+ optional: true
+ '@vitejs/devtools':
+ optional: true
+ esbuild:
+ optional: true
+ jiti:
+ optional: true
+ less:
+ optional: true
+ sass:
+ optional: true
+ sass-embedded:
+ optional: true
+ stylus:
+ optional: true
+ sugarss:
+ optional: true
+ terser:
+ optional: true
+ tsx:
+ optional: true
+ yaml:
+ optional: true
+
+ resolution: {integrity: sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==}
+ engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+ hasBin: true
+ peerDependencies:
+ '@edge-runtime/vm': '*'
+ '@opentelemetry/api': ^1.9.0
+ '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+ '@vitest/browser-playwright': 4.1.10
+ '@vitest/browser-preview': 4.1.10
+ '@vitest/browser-webdriverio': 4.1.10
+ '@vitest/coverage-istanbul': 4.1.10
+ '@vitest/coverage-v8': 4.1.10
+ '@vitest/ui': 4.1.10
+ happy-dom: '*'
+ jsdom: '*'
+ vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+ peerDependenciesMeta:
+ '@edge-runtime/vm':
+ optional: true
+ '@opentelemetry/api':
+ optional: true
+ '@types/node':
+ optional: true
+ '@vitest/browser-playwright':
+ optional: true
+ '@vitest/browser-preview':
+ optional: true
+ '@vitest/browser-webdriverio':
+ optional: true
+ '@vitest/coverage-istanbul':
+ optional: true
+ '@vitest/coverage-v8':
+ optional: true
+ '@vitest/ui':
+ optional: true
+ happy-dom:
+ optional: true
+ jsdom:
+ optional: true
+
+ resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+ engines: {node: '>=8'}
+ hasBin: true
+
+snapshots:
+
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@atlaskit/pragmatic-drag-and-drop': 3.0.0
+ '@babel/runtime': 7.29.7
+
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@atlaskit/pragmatic-drag-and-drop': 3.0.0
+ '@babel/runtime': 7.29.7
+
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@babel/runtime': 7.29.7
+
+ '@atlaskit/[email protected]':
+ dependencies:
+ '@babel/runtime': 7.29.7
+ bind-event-listener: 3.0.0
+ raf-schd: 4.0.3
+
+ '@babel/[email protected]': {}
+
+ '@jridgewell/[email protected]': {}
+
+ '@oxc-project/[email protected]': {}
+
+ '@playwright/[email protected]':
+ dependencies:
+ playwright: 1.62.1
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]': {}
+
+ '@standard-schema/[email protected]': {}
+
+ '@types/[email protected]':
+ dependencies:
+ '@types/deep-eql': 4.0.2
+ assertion-error: 2.0.1
+
+ '@types/[email protected]': {}
+
+ '@types/[email protected]': {}
+
+ '@types/[email protected]':
+ dependencies:
+ undici-types: 7.24.6
+
+ '@vitest/[email protected]':
+ dependencies:
+ '@standard-schema/spec': 1.1.0
+ '@types/chai': 5.2.3
+ '@vitest/spy': 4.1.10
+ '@vitest/utils': 4.1.10
+ chai: 6.2.2
+ tinyrainbow: 3.1.1
+
+ dependencies:
+ '@vitest/spy': 4.1.10
+ estree-walker: 3.0.3
+ magic-string: 0.30.21
+ optionalDependencies:
+ vite: 8.2.2(@types/[email protected])
+
+ '@vitest/[email protected]':
+ dependencies:
+ tinyrainbow: 3.1.1
+
+ '@vitest/[email protected]':
+ dependencies:
+ '@vitest/utils': 4.1.10
+ pathe: 2.0.3
+
+ '@vitest/[email protected]':
+ dependencies:
+ '@vitest/pretty-format': 4.1.10
+ '@vitest/utils': 4.1.10
+ magic-string: 0.30.21
+ pathe: 2.0.3
+
+ '@vitest/[email protected]': {}
+
+ '@vitest/[email protected]':
+ dependencies:
+ '@vitest/pretty-format': 4.1.10
+ convert-source-map: 2.0.0
+ tinyrainbow: 3.1.1
+
+
+
+
+
+
+
+ dependencies:
+ '@types/estree': 1.0.9
+
+
+ optionalDependencies:
+ picomatch: 4.0.7
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ optional: true
+
+ dependencies:
+ detect-libc: 2.1.2
+ optionalDependencies:
+ lightningcss-android-arm64: 1.33.0
+ lightningcss-darwin-arm64: 1.33.0
+ lightningcss-darwin-x64: 1.33.0
+ lightningcss-freebsd-x64: 1.33.0
+ lightningcss-linux-arm-gnueabihf: 1.33.0
+ lightningcss-linux-arm64-gnu: 1.33.0
+ lightningcss-linux-arm64-musl: 1.33.0
+ lightningcss-linux-x64-gnu: 1.33.0
+ lightningcss-linux-x64-musl: 1.33.0
+ lightningcss-win32-arm64-msvc: 1.33.0
+ lightningcss-win32-x64-msvc: 1.33.0
+
+ dependencies:
+ '@jridgewell/sourcemap-codec': 1.5.5
+
+
+
+
+
+
+
+ dependencies:
+ playwright-core: 1.62.1
+ optionalDependencies:
+ fsevents: 2.3.2
+
+ dependencies:
+ nanoid: 3.3.18
+ picocolors: 1.1.1
+ source-map-js: 1.2.1
+
+
+ dependencies:
+ '@oxc-project/types': 0.147.0
+ '@rolldown/pluginutils': 1.0.1
+ optionalDependencies:
+ '@rolldown/binding-android-arm-eabi': 1.2.6
+ '@rolldown/binding-android-arm64': 1.2.6
+ '@rolldown/binding-darwin-arm64': 1.2.6
+ '@rolldown/binding-darwin-x64': 1.2.6
+ '@rolldown/binding-freebsd-x64': 1.2.6
+ '@rolldown/binding-linux-arm-gnueabihf': 1.2.6
+ '@rolldown/binding-linux-arm64-gnu': 1.2.6
+ '@rolldown/binding-linux-arm64-musl': 1.2.6
+ '@rolldown/binding-linux-ppc64-gnu': 1.2.6
+ '@rolldown/binding-linux-s390x-gnu': 1.2.6
+ '@rolldown/binding-linux-x64-gnu': 1.2.6
+ '@rolldown/binding-linux-x64-musl': 1.2.6
+ '@rolldown/binding-openharmony-arm64': 1.2.6
+ '@rolldown/binding-win32-arm64-msvc': 1.2.6
+ '@rolldown/binding-win32-x64-msvc': 1.2.6
+
+
+
+
+
+
+
+ dependencies:
+ fdir: 6.5.0([email protected])
+ picomatch: 4.0.7
+
+
+
+
+ dependencies:
+ lightningcss: 1.33.0
+ picomatch: 4.0.7
+ postcss: 8.5.26
+ rolldown: 1.2.6
+ tinyglobby: 0.2.17
+ optionalDependencies:
+ '@types/node': 25.9.4
+ fsevents: 2.3.3
+
+ dependencies:
+ '@vitest/expect': 4.1.10
+ '@vitest/mocker': 4.1.10([email protected](@types/[email protected]))
+ '@vitest/pretty-format': 4.1.10
+ '@vitest/runner': 4.1.10
+ '@vitest/snapshot': 4.1.10
+ '@vitest/spy': 4.1.10
+ '@vitest/utils': 4.1.10
+ es-module-lexer: 2.3.2
+ expect-type: 1.4.0
+ magic-string: 0.30.21
+ obug: 2.1.4
+ pathe: 2.0.3
+ picomatch: 4.0.7
+ std-env: 4.2.0
+ tinybench: 2.9.0
+ tinyexec: 1.3.0
+ tinyglobby: 0.2.17
+ tinyrainbow: 3.1.1
+ vite: 8.2.2(@types/[email protected])
+ why-is-node-running: 2.3.0
+ optionalDependencies:
+ '@types/node': 25.9.4
+ transitivePeerDependencies:
+ - msw
+
+ dependencies:
+ siginfo: 2.0.0
+ stackback: 0.0.2
diff --git a/spikes/server-rail-pdd/src/css.d.ts b/spikes/server-rail-pdd/src/css.d.ts
new file mode 100644
index 000000000..d7e961ee2
--- /dev/null
+++ b/spikes/server-rail-pdd/src/css.d.ts
@@ -0,0 +1 @@
+declare module "*.css"
diff --git a/spikes/server-rail-pdd/src/main.ts b/spikes/server-rail-pdd/src/main.ts
new file mode 100644
index 000000000..639f7e935
--- /dev/null
+++ b/spikes/server-rail-pdd/src/main.ts
@@ -0,0 +1,548 @@
+import { autoScrollForElements } from "@atlaskit/pragmatic-drag-and-drop-auto-scroll/element"
+import {
+ attachInstruction,
+ extractInstruction,
+ type Availability,
+} from "@atlaskit/pragmatic-drag-and-drop-hitbox/list-item"
+import { announce, cleanup as cleanupLiveRegion } from "@atlaskit/pragmatic-drag-and-drop-live-region"
+import {
+ draggable,
+ dropTargetForElements,
+ monitorForElements,
+} from "@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter"
+import {
+ accessibleMoveLabel,
+ cloneState,
+ commitInstruction,
+ folderForServer,
+ planPersistence,
+ visibleTopLevelServers,
+ type Entity,
+ type PersistenceCommand,
+ type RailInstruction,
+ type RailState,
+} from "./rail-model"
+import "./styles.css"
+
+type EventEntry = {
+ index: number
+ type: string
+ instruction?: RailInstruction
+ commands?: PersistenceCommand[]
+ detail?: string
+}
+
+type SpikeReadout = {
+ state: RailState
+ events: EventEntry[]
+ clickCount: number
+ commitCount: number
+ persistenceBatchCount: number
+ rollbackCount: number
+ failNext: boolean
+ preview: RailInstruction | null
+}
+
+declare global {
+ interface Window {
+ __railSpike: {
+ read: () => SpikeReadout
+ reset: () => void
+ failNextPersistence: () => void
+ }
+ }
+}
+
+function requiredElement(selector: string): HTMLElement {
+ const element = document.querySelector<HTMLElement>(selector)
+ if (!element) throw new Error(`missing element ${selector}`)
+ return element
+}
+
+const app = requiredElement("#app")
+const eventOutput = requiredElement("#events")
+
+function makeFixture(): RailState {
+ return {
+ serverOrder: Array.from({ length: 18 }, (_, index) => String.fromCharCode(97 + index)),
+ folderOrder: ["one", "two"],
+ folders: { one: ["c", "d"], two: ["e", "f"] },
+ expanded: ["one"],
+ }
+}
+
+let state = makeFixture()
+let events: EventEntry[] = []
+let clickCount = 0
+let commitCount = 0
+let persistenceBatchCount = 0
+let rollbackCount = 0
+let failNext = false
+let preview: RailInstruction | null = null
+let dragStartSnapshot: RailState | null = null
+let dragSource: Entity | null = null
+let folderSequence = 0
+let interactionCleanups: Array<() => void> = []
+let hoverTimer: number | null = null
+let hoverFolderId: string | null = null
+const transientCollapsed = new Set<string>()
+const transientExpanded = new Set<string>()
+
+function entityKey(entity: Entity): string {
+ return `${entity.kind}-${entity.id}`
+}
+
+function sameEntity(left: Entity | null, right: Entity | null): boolean {
+ return left?.kind === right?.kind && left?.id === right?.id
+}
+
+function entityFromData(data: Record<string | symbol, unknown>): Entity | null {
+ const kind = data.railKind
+ const id = data.railId
+ if ((kind !== "server" && kind !== "folder") || typeof id !== "string") return null
+ return { kind, id }
+}
+
+function record(type: string, values: Omit<EventEntry, "index" | "type"> = {}): void {
+ events.push({ index: events.length + 1, type, ...values })
+ eventOutput.textContent = JSON.stringify(events, null, 2)
+}
+
+function readout(): SpikeReadout {
+ return {
+ state: cloneState(state),
+ events: structuredClone(events),
+ clickCount,
+ commitCount,
+ persistenceBatchCount,
+ rollbackCount,
+ failNext,
+ preview: preview ? structuredClone(preview) : null,
+ }
+}
+
+function clearHoverTimer(): void {
+ if (hoverTimer !== null) window.clearTimeout(hoverTimer)
+ hoverTimer = null
+ hoverFolderId = null
+}
+
+function effectiveExpanded(folderId: string): boolean {
+ if (transientCollapsed.has(folderId)) return false
+ return state.expanded.includes(folderId) || transientExpanded.has(folderId)
+}
+
+function setFolderChildrenVisibility(folderId: string): void {
+ const element = document.querySelector<HTMLElement>(`[data-folder-children="${folderId}"]`)
+ if (element) element.hidden = !effectiveExpanded(folderId)
+ const row = document.querySelector<HTMLElement>(`[data-testid="rail-item-folder-${folderId}"]`)
+ row?.setAttribute("aria-expanded", String(effectiveExpanded(folderId)))
+}
+
+function resetTransientDragState(): void {
+ clearHoverTimer()
+ preview = null
+ dragStartSnapshot = null
+ dragSource = null
+ transientCollapsed.clear()
+ transientExpanded.clear()
+}
+
+function focusEntity(entity: Entity): void {
+ requestAnimationFrame(() => {
+ document.querySelector<HTMLElement>(`[data-testid="primary-${entityKey(entity)}"]`)?.focus()
+ })
+}
+
+function finishCommit(
+ before: RailState,
+ instruction: RailInstruction,
+ source: "pointer" | "move-menu",
+): void {
+ const committed = commitInstruction(before, instruction)
+ if (!committed.applied) {
+ record("invalid-drop", { instruction, detail: committed.reason })
+ render(instruction.source)
+ return
+ }
+
+ const commands = planPersistence(before, committed.state, instruction)
+ const shouldFail = failNext
+ failNext = false
+ state = committed.state
+ commitCount += 1
+ persistenceBatchCount += 1
+ record("optimistic-commit", { instruction, commands, detail: source })
+ render(instruction.source)
+
+ window.setTimeout(() => {
+ if (shouldFail) {
+ state = cloneState(before)
+ rollbackCount += 1
+ record("rollback", { instruction, commands })
+ announce(`${accessibleMoveLabel(before, instruction)} failed and was rolled back`)
+ render(instruction.source)
+ return
+ }
+ const label = accessibleMoveLabel(before, instruction)
+ record("persisted", { instruction, commands, detail: label })
+ announce(label)
+ focusEntity(instruction.source)
+ }, 80)
+}
+
+function instructionWithFolderId(instruction: RailInstruction, before: RailState): RailInstruction {
+ if (
+ instruction.operation !== "combine"
+ || instruction.source.kind !== "server"
+ || instruction.target.kind !== "server"
+ || folderForServer(before, instruction.source.id)
+ || folderForServer(before, instruction.target.id)
+ ) {
+ return instruction
+ }
+ folderSequence += 1
+ return { ...instruction, newFolderId: `temporary-${folderSequence}` }
+}
+
+function instructionFromDropTargets(
+ sourceData: Record<string | symbol, unknown>,
+ targets: readonly { data: Record<string | symbol, unknown> }[],
+): RailInstruction | null {
+ const source = entityFromData(sourceData)
+ const targetRecord = targets[0]
+ if (!source || !targetRecord) return null
+ const target = entityFromData(targetRecord.data)
+ const hitbox = extractInstruction(targetRecord.data)
+ if (!target || !hitbox || hitbox.blocked || sameEntity(source, target)) return null
+ return { operation: hitbox.operation, source, target }
+}
+
+function sameInstruction(left: RailInstruction | null, right: RailInstruction | null): boolean {
+ return left?.operation === right?.operation
+ && sameEntity(left?.source ?? null, right?.source ?? null)
+ && sameEntity(left?.target ?? null, right?.target ?? null)
+}
+
+function clearPreviewClasses(): void {
+ for (const element of document.querySelectorAll<HTMLElement>(".preview-before, .preview-after, .preview-combine")) {
+ element.classList.remove("preview-before", "preview-after", "preview-combine")
+ }
+}
+
+function updateHoverExpansion(instruction: RailInstruction | null): void {
+ const folderId = instruction?.operation === "combine" && instruction.target.kind === "folder"
+ ? instruction.target.id
+ : null
+ if (!folderId || effectiveExpanded(folderId)) {
+ clearHoverTimer()
+ return
+ }
+ if (hoverFolderId === folderId && hoverTimer !== null) return
+ clearHoverTimer()
+ hoverFolderId = folderId
+ hoverTimer = window.setTimeout(() => {
+ transientExpanded.add(folderId)
+ setFolderChildrenVisibility(folderId)
+ record("hover-expand", { detail: folderId })
+ hoverTimer = null
+ }, 500)
+}
+
+function updatePreview(
+ sourceData: Record<string | symbol, unknown>,
+ targets: readonly { data: Record<string | symbol, unknown> }[],
+): void {
+ const next = instructionFromDropTargets(sourceData, targets)
+ if (sameInstruction(preview, next)) return
+ preview = next
+ clearPreviewClasses()
+ if (next) {
+ const target = document.querySelector<HTMLElement>(`[data-testid="rail-item-${entityKey(next.target)}"]`)
+ target?.classList.add(
+ next.operation === "reorder-before"
+ ? "preview-before"
+ : next.operation === "reorder-after"
+ ? "preview-after"
+ : "preview-combine",
+ )
+ record("preview", { instruction: next })
+ } else {
+ record("preview-cleared")
+ }
+ updateHoverExpansion(next)
+}
+
+function operationAvailability(source: Entity | null, target: Entity): {
+ "reorder-before": Availability
+ "reorder-after": Availability
+ combine: Availability
+} {
+ const canReorder = source?.kind === target.kind
+ const canCombine = source?.kind === "server" && (target.kind === "folder" || target.kind === "server")
+ return {
+ "reorder-before": canReorder ? "available" : "not-available",
+ "reorder-after": canReorder ? "available" : "not-available",
+ combine: canCombine ? "available" : "not-available",
+ }
+}
+
+function makeMoveOption(
+ label: string,
+ testId: string,
+ instruction: RailInstruction,
+ container: HTMLElement,
+): void {
+ const button = document.createElement("button")
+ button.type = "button"
+ button.role = "menuitem"
+ button.dataset.testid = testId
+ button.textContent = label
+ button.addEventListener("click", () => {
+ finishCommit(cloneState(state), instructionWithFolderId(instruction, state), "move-menu")
+ })
+ container.append(button)
+}
+
+function buildMoveMenu(entity: Entity): HTMLElement {
+ const menu = document.createElement("div")
+ menu.className = "move-menu"
+ menu.role = "menu"
+ menu.hidden = true
+ menu.dataset.testid = `move-menu-${entityKey(entity)}`
+
+ if (entity.kind === "folder") {
+ for (const targetId of state.folderOrder.filter((id) => id !== entity.id)) {
+ for (const operation of ["reorder-before", "reorder-after"] as const) {
+ makeMoveOption(
+ `Move ${operation === "reorder-before" ? "before" : "after"} folder ${targetId}`,
+ `move-${entityKey(entity)}-${operation}-${targetId}`,
+ { operation, source: entity, target: { kind: "folder", id: targetId } },
+ menu,
+ )
+ }
+ }
+ return menu
+ }
+
+ for (const targetId of state.serverOrder.filter((id) => id !== entity.id)) {
+ for (const operation of ["reorder-before", "reorder-after"] as const) {
+ makeMoveOption(
+ `Move ${operation === "reorder-before" ? "before" : "after"} server ${targetId}`,
+ `move-${entityKey(entity)}-${operation}-${targetId}`,
+ { operation, source: entity, target: { kind: "server", id: targetId } },
+ menu,
+ )
+ }
+ }
+ for (const folderId of state.folderOrder) {
+ makeMoveOption(
+ `Move into folder ${folderId}`,
+ `move-${entityKey(entity)}-into-${folderId}`,
+ { operation: "combine", source: entity, target: { kind: "folder", id: folderId } },
+ menu,
+ )
+ }
+ for (const targetId of visibleTopLevelServers(state).filter((id) => id !== entity.id)) {
+ makeMoveOption(
+ `Combine with server ${targetId}`,
+ `move-${entityKey(entity)}-combine-${targetId}`,
+ { operation: "combine", source: entity, target: { kind: "server", id: targetId } },
+ menu,
+ )
+ }
+ return menu
+}
+
+function renderRow(entity: Entity, parentFolderId: string | null): HTMLElement {
+ const row = document.createElement("div")
+ row.className = "rail-row"
+ row.dataset.testid = `rail-item-${entityKey(entity)}`
+ row.dataset.level = parentFolderId ? "1" : "0"
+ if (entity.kind === "folder") row.setAttribute("aria-expanded", String(effectiveExpanded(entity.id)))
+
+ const primary = document.createElement("button")
+ primary.type = "button"
+ primary.className = "primary-action"
+ primary.dataset.testid = `primary-${entityKey(entity)}`
+ primary.textContent = entity.kind === "server" ? `Server ${entity.id}` : `Folder ${entity.id}`
+ primary.addEventListener("click", () => {
+ clickCount += 1
+ record("click", { detail: entityKey(entity) })
+ if (entity.kind === "folder") {
+ state.expanded = state.expanded.includes(entity.id)
+ ? state.expanded.filter((id) => id !== entity.id)
+ : [...state.expanded, entity.id]
+ render(entity)
+ }
+ })
+
+ const moveTrigger = document.createElement("button")
+ moveTrigger.type = "button"
+ moveTrigger.className = "move-trigger"
+ moveTrigger.dataset.testid = `move-trigger-${entityKey(entity)}`
+ moveTrigger.setAttribute("aria-haspopup", "menu")
+ moveTrigger.textContent = "Move…"
+
+ const menu = buildMoveMenu(entity)
+ moveTrigger.addEventListener("click", () => {
+ menu.hidden = !menu.hidden
+ moveTrigger.setAttribute("aria-expanded", String(!menu.hidden))
+ })
+
+ row.append(primary, moveTrigger, menu)
+ return row
+}
+
+function renderFolder(folderId: string): HTMLElement {
+ const wrapper = document.createElement("section")
+ wrapper.className = "folder"
+ wrapper.append(renderRow({ kind: "folder", id: folderId }, null))
+ const children = document.createElement("div")
+ children.className = "folder-children"
+ children.dataset.folderChildren = folderId
+ children.hidden = !effectiveExpanded(folderId)
+ for (const serverId of state.folders[folderId] ?? []) {
+ children.append(renderRow({ kind: "server", id: serverId }, folderId))
+ }
+ wrapper.append(children)
+ return wrapper
+}
+
+function wireInteractions(rail: HTMLElement): void {
+ for (const cleanup of interactionCleanups.splice(0)) cleanup()
+
+ for (const row of rail.querySelectorAll<HTMLElement>(".rail-row")) {
+ const kind = row.dataset.testid?.includes("-folder-") ? "folder" : "server"
+ const id = row.dataset.testid?.split(`-${kind}-`)[1]
+ const primary = row.querySelector<HTMLElement>(".primary-action")
+ if (!id || !primary) continue
+ const entity: Entity = { kind, id }
+
+ interactionCleanups.push(draggable({
+ element: row,
+ dragHandle: primary,
+ getInitialData: () => ({ railKind: entity.kind, railId: entity.id }),
+ }))
+
+ interactionCleanups.push(dropTargetForElements({
+ element: row,
+ canDrop: ({ source }) => !sameEntity(entityFromData(source.data), entity),
+ getIsSticky: () => false,
+ getData: ({ input, element, source }) => attachInstruction(
+ { railKind: entity.kind, railId: entity.id },
+ {
+ input,
+ element,
+ axis: "vertical",
+ operations: operationAvailability(entityFromData(source.data), entity),
+ },
+ ),
+ }))
+ }
+
+ interactionCleanups.push(autoScrollForElements({
+ element: rail,
+ getAllowedAxis: () => "vertical",
+ getConfiguration: () => ({ maxScrollSpeed: "fast" }),
+ }))
+
+ interactionCleanups.push(monitorForElements({
+ canMonitor: ({ source }) => entityFromData(source.data) !== null,
+ onDragStart: ({ source }) => {
+ dragStartSnapshot = cloneState(state)
+ dragSource = entityFromData(source.data)
+ if (dragSource?.kind === "folder" && state.expanded.includes(dragSource.id)) {
+ transientCollapsed.add(dragSource.id)
+ setFolderChildrenVisibility(dragSource.id)
+ }
+ record("drag-start", { detail: dragSource ? entityKey(dragSource) : "unknown" })
+ },
+ onDrag: ({ source, location }) => {
+ updatePreview(source.data, location.current.dropTargets)
+ },
+ onDropTargetChange: ({ source, location }) => {
+ updatePreview(source.data, location.current.dropTargets)
+ },
+ onDrop: ({ source, location }) => {
+ const before = dragStartSnapshot ? cloneState(dragStartSnapshot) : cloneState(state)
+ const rawInstruction = instructionFromDropTargets(source.data, location.current.dropTargets)
+ resetTransientDragState()
+ clearPreviewClasses()
+ if (!rawInstruction) {
+ record("cancel")
+ render(dragSource ?? undefined)
+ return
+ }
+ finishCommit(before, instructionWithFolderId(rawInstruction, before), "pointer")
+ },
+ }))
+}
+
+function render(focusAfter?: Entity): void {
+ const scrollTop = app.querySelector<HTMLElement>("[data-testid='rail-scroll']")?.scrollTop ?? 0
+ app.replaceChildren()
+
+ const controls = document.createElement("div")
+ controls.className = "controls"
+ const resetButton = document.createElement("button")
+ resetButton.type = "button"
+ resetButton.dataset.testid = "reset"
+ resetButton.textContent = "Reset fixture"
+ resetButton.addEventListener("click", resetFixture)
+ const failureButton = document.createElement("button")
+ failureButton.type = "button"
+ failureButton.dataset.testid = "fail-next"
+ failureButton.textContent = failNext ? "Next persistence will fail" : "Fail next persistence"
+ failureButton.addEventListener("click", () => {
+ failNext = true
+ record("failure-armed")
+ render(focusAfter)
+ })
+ controls.append(resetButton, failureButton)
+
+ const rail = document.createElement("div")
+ rail.className = "rail-scroll"
+ rail.dataset.testid = "rail-scroll"
+ rail.setAttribute("aria-label", "Server rail")
+ for (const folderId of state.folderOrder) rail.append(renderFolder(folderId))
+ for (const serverId of visibleTopLevelServers(state)) {
+ rail.append(renderRow({ kind: "server", id: serverId }, null))
+ }
+
+ app.append(controls, rail)
+ rail.scrollTop = scrollTop
+ wireInteractions(rail)
+ if (focusAfter) focusEntity(focusAfter)
+}
+
+function resetFixture(): void {
+ state = makeFixture()
+ events = []
+ clickCount = 0
+ commitCount = 0
+ persistenceBatchCount = 0
+ rollbackCount = 0
+ failNext = false
+ folderSequence = 0
+ resetTransientDragState()
+ eventOutput.textContent = "[]"
+ render()
+}
+
+window.__railSpike = {
+ read: readout,
+ reset: resetFixture,
+ failNextPersistence: () => {
+ failNext = true
+ record("failure-armed")
+ render()
+ },
+}
+
+window.addEventListener("pagehide", () => {
+ for (const dispose of interactionCleanups) dispose()
+ cleanupLiveRegion()
+}, { once: true })
+
+render()
diff --git a/spikes/server-rail-pdd/src/rail-model.test.ts b/spikes/server-rail-pdd/src/rail-model.test.ts
new file mode 100644
index 000000000..29599e89b
--- /dev/null
+++ b/spikes/server-rail-pdd/src/rail-model.test.ts
@@ -0,0 +1,210 @@
+import { describe, expect, it } from "vitest"
+import {
+ MAX_FOLDERS,
+ accessibleMoveLabel,
+ cloneState,
+ commitInstruction,
+ planPersistence,
+ stateErrors,
+ visibleTopLevelServers,
+ type RailInstruction,
+ type RailState,
+} from "./rail-model"
+
+function fixture(): RailState {
+ return {
+ serverOrder: ["a", "b", "c", "d", "e", "f"],
+ folderOrder: ["one", "two"],
+ folders: { one: ["c", "d"], two: ["e"] },
+ expanded: ["one"],
+ }
+}
+
+function apply(instruction: RailInstruction, state = fixture()) {
+ return commitInstruction(state, instruction)
+}
+
+describe("normalized server rail reducer", () => {
+ it("keeps global membership order while deriving visible top-level servers", () => {
+ expect(visibleTopLevelServers(fixture())).toEqual(["a", "b", "f"])
+ expect(stateErrors(fixture())).toEqual([])
+ })
+
+ it("reorders top-level servers with the full membership sequence", () => {
+ const before = fixture()
+ const instruction: RailInstruction = {
+ operation: "reorder-after",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "b" },
+ }
+ const result = commitInstruction(before, instruction)
+ expect(result.applied).toBe(true)
+ expect(result.state.serverOrder).toEqual(["b", "a", "c", "d", "e", "f"])
+ expect(planPersistence(before, result.state, instruction)).toEqual([
+ { type: "reorder-servers", serverIds: ["b", "a", "c", "d", "e", "f"] },
+ ])
+
+ const beforeResult = apply({
+ operation: "reorder-before",
+ source: { kind: "server", id: "f" },
+ target: { kind: "server", id: "a" },
+ })
+ expect(beforeResult.state.serverOrder).toEqual(["f", "a", "b", "c", "d", "e"])
+ })
+
+ it("reorders folders without inventing cross-kind positions", () => {
+ const before = fixture()
+ const instruction: RailInstruction = {
+ operation: "reorder-before",
+ source: { kind: "folder", id: "two" },
+ target: { kind: "folder", id: "one" },
+ }
+ const result = commitInstruction(before, instruction)
+ expect(result.state.folderOrder).toEqual(["two", "one"])
+ expect(planPersistence(before, result.state, instruction)).toEqual([
+ { type: "reorder-folders", folderIds: ["two", "one"] },
+ ])
+
+ expect(apply({
+ operation: "reorder-before",
+ source: { kind: "server", id: "a" },
+ target: { kind: "folder", id: "one" },
+ })).toMatchObject({ applied: false, reason: "server and folder orders cannot interleave" })
+ })
+
+ it("reorders within a folder with one folder update", () => {
+ const before = fixture()
+ const instruction: RailInstruction = {
+ operation: "reorder-before",
+ source: { kind: "server", id: "d" },
+ target: { kind: "server", id: "c" },
+ }
+ const result = commitInstruction(before, instruction)
+ expect(result.state.folders.one).toEqual(["d", "c"])
+ expect(result.state.serverOrder).toEqual(before.serverOrder)
+ expect(planPersistence(before, result.state, instruction)).toEqual([
+ { type: "update-folder", folderId: "one", serverIds: ["d", "c"] },
+ ])
+ })
+
+ it("moves a top-level server into a folder and expands the destination", () => {
+ const before = fixture()
+ const instruction: RailInstruction = {
+ operation: "combine",
+ source: { kind: "server", id: "a" },
+ target: { kind: "folder", id: "two" },
+ }
+ const result = commitInstruction(before, instruction)
+ expect(result.state.folders.two).toEqual(["e", "a"])
+ expect(result.state.expanded).toEqual(["one", "two"])
+ expect(result.state.serverOrder).toEqual(before.serverOrder)
+ expect(planPersistence(before, result.state, instruction)).toEqual([
+ { type: "update-folder", folderId: "two", serverIds: ["e", "a"] },
+ ])
+ })
+
+ it("moves a server between folders with the two necessary updates", () => {
+ const before = fixture()
+ const instruction: RailInstruction = {
+ operation: "reorder-after",
+ source: { kind: "server", id: "c" },
+ target: { kind: "server", id: "e" },
+ }
+ const result = commitInstruction(before, instruction)
+ expect(result.state.folders).toEqual({ one: ["d"], two: ["e", "c"] })
+ expect(result.state.expanded).toEqual(["one", "two"])
+ expect(planPersistence(before, result.state, instruction)).toEqual([
+ { type: "update-folder", folderId: "one", serverIds: ["d"] },
+ { type: "update-folder", folderId: "two", serverIds: ["e", "c"] },
+ ])
+ })
+
+ it("moves the last folder server to rail and deletes the empty folder", () => {
+ const before = fixture()
+ const instruction: RailInstruction = {
+ operation: "reorder-before",
+ source: { kind: "server", id: "e" },
+ target: { kind: "server", id: "f" },
+ }
+ const result = commitInstruction(before, instruction)
+ expect(visibleTopLevelServers(result.state)).toEqual(["a", "b", "e", "f"])
+ expect(result.state.folderOrder).toEqual(["one"])
+ expect(result.state.serverOrder).toEqual(["a", "b", "c", "d", "e", "f"])
+ expect(planPersistence(before, result.state, instruction)).toEqual([
+ { type: "update-folder", folderId: "two", serverIds: [] },
+ ])
+ })
+
+ it("creates a temporary folder only from two top-level servers", () => {
+ const before = fixture()
+ const instruction: RailInstruction = {
+ operation: "combine",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "b" },
+ newFolderId: "temp-1",
+ }
+ const result = commitInstruction(before, instruction)
+ expect(result.state.folderOrder).toEqual(["one", "two", "temp-1"])
+ expect(result.state.folders["temp-1"]).toEqual(["a", "b"])
+ expect(planPersistence(before, result.state, instruction)).toEqual([
+ { type: "create-folder", tempFolderId: "temp-1", serverIds: ["a", "b"] },
+ ])
+
+ expect(apply({
+ ...instruction,
+ source: { kind: "server", id: "c" },
+ })).toMatchObject({
+ applied: false,
+ reason: "creating a folder requires two top-level servers",
+ })
+ })
+
+ it("blocks new folders at the limit", () => {
+ const state = fixture()
+ state.folderOrder = Array.from({ length: MAX_FOLDERS }, (_, index) => `f${index}`)
+ state.folders = Object.fromEntries(
+ state.folderOrder.map((folderId, index) => [folderId, [`extra-${index}`]]),
+ )
+ state.serverOrder.push(...Object.values(state.folders).flat())
+ state.expanded = []
+ const result = commitInstruction(state, {
+ operation: "combine",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "b" },
+ newFolderId: "too-many",
+ })
+ expect(result).toMatchObject({ applied: false, reason: "folder limit reached" })
+ })
+
+ it("treats preview, cancel, self drops, and invalid state as zero-write", () => {
+ const before = fixture()
+ const snapshot = cloneState(before)
+ const self = apply({
+ operation: "reorder-before",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "a" },
+ })
+ expect(self.applied).toBe(false)
+ expect(planPersistence(before, snapshot, {
+ operation: "reorder-before",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "b" },
+ })).toEqual([])
+
+ const invalid = fixture()
+ invalid.folders.two.push("c")
+ expect(commitInstruction(invalid, {
+ operation: "combine",
+ source: { kind: "server", id: "a" },
+ target: { kind: "folder", id: "one" },
+ })).toMatchObject({ applied: false, reason: "invalid start state" })
+ })
+
+ it("produces a literal accessible outcome", () => {
+ expect(accessibleMoveLabel(fixture(), {
+ operation: "reorder-after",
+ source: { kind: "server", id: "c" },
+ target: { kind: "server", id: "e" },
+ })).toBe("Server c moved after server e from folder one")
+ })
+})
diff --git a/spikes/server-rail-pdd/src/rail-model.ts b/spikes/server-rail-pdd/src/rail-model.ts
new file mode 100644
index 000000000..8a61e9e34
--- /dev/null
+++ b/spikes/server-rail-pdd/src/rail-model.ts
@@ -0,0 +1,356 @@
+export const MAX_FOLDERS = 10
+
+export type Entity =
+ | { kind: "server"; id: string }
+ | { kind: "folder"; id: string }
+
+export type Operation = "reorder-before" | "reorder-after" | "combine"
+
+export type RailInstruction = {
+ operation: Operation
+ source: Entity
+ target: Entity
+ newFolderId?: string
+}
+
+export type RailState = {
+ serverOrder: string[]
+ folderOrder: string[]
+ folders: Record<string, string[]>
+ expanded: string[]
+}
+
+export type PersistenceCommand =
+ | { type: "reorder-servers"; serverIds: string[] }
+ | { type: "reorder-folders"; folderIds: string[] }
+ | { type: "update-folder"; folderId: string; serverIds: string[] }
+ | { type: "create-folder"; tempFolderId: string; serverIds: string[] }
+
+export type CommitResult = {
+ state: RailState
+ applied: boolean
+ reason?: string
+}
+
+function unique(values: readonly string[]): string[] {
+ return [...new Set(values)]
+}
+
+export function cloneState(state: RailState): RailState {
+ return {
+ serverOrder: [...state.serverOrder],
+ folderOrder: [...state.folderOrder],
+ folders: Object.fromEntries(
+ Object.entries(state.folders).map(([folderId, serverIds]) => [folderId, [...serverIds]]),
+ ),
+ expanded: [...state.expanded],
+ }
+}
+
+export function visibleTopLevelServers(state: RailState): string[] {
+ const claimed = new Set(Object.values(state.folders).flat())
+ return state.serverOrder.filter((serverId) => !claimed.has(serverId))
+}
+
+export function folderForServer(state: RailState, serverId: string): string | null {
+ for (const folderId of state.folderOrder) {
+ if (state.folders[folderId]?.includes(serverId)) return folderId
+ }
+ return null
+}
+
+export function stateErrors(state: RailState): string[] {
+ const errors: string[] = []
+ const serverSet = new Set(state.serverOrder)
+ if (serverSet.size !== state.serverOrder.length) errors.push("serverOrder contains duplicates")
+ if (new Set(state.folderOrder).size !== state.folderOrder.length) {
+ errors.push("folderOrder contains duplicates")
+ }
+ if (state.folderOrder.length > MAX_FOLDERS) errors.push("folder limit exceeded")
+
+ const memberships = new Set<string>()
+ for (const folderId of state.folderOrder) {
+ const items = state.folders[folderId]
+ if (!items) {
+ errors.push(`folder ${folderId} is missing`)
+ continue
+ }
+ if (items.length === 0) errors.push(`folder ${folderId} is empty`)
+ if (new Set(items).size !== items.length) errors.push(`folder ${folderId} contains duplicates`)
+ for (const serverId of items) {
+ if (!serverSet.has(serverId)) errors.push(`folder ${folderId} contains unknown server ${serverId}`)
+ if (memberships.has(serverId)) errors.push(`server ${serverId} belongs to multiple folders`)
+ memberships.add(serverId)
+ }
+ }
+ for (const folderId of Object.keys(state.folders)) {
+ if (!state.folderOrder.includes(folderId)) errors.push(`folder ${folderId} is not ordered`)
+ }
+ for (const folderId of state.expanded) {
+ if (!state.folderOrder.includes(folderId)) errors.push(`expanded folder ${folderId} is missing`)
+ }
+ return errors
+}
+
+function sameArray(left: readonly string[], right: readonly string[]): boolean {
+ return left.length === right.length && left.every((value, index) => value === right[index])
+}
+
+export function sameState(left: RailState, right: RailState): boolean {
+ if (!sameArray(left.serverOrder, right.serverOrder)) return false
+ if (!sameArray(left.folderOrder, right.folderOrder)) return false
+ if (!sameArray(left.expanded, right.expanded)) return false
+ return left.folderOrder.every((folderId) =>
+ sameArray(left.folders[folderId] ?? [], right.folders[folderId] ?? []),
+ )
+}
+
+function moveRelative(list: readonly string[], sourceId: string, targetId: string, after: boolean): string[] {
+ const withoutSource = list.filter((id) => id !== sourceId)
+ const targetIndex = withoutSource.indexOf(targetId)
+ if (targetIndex === -1) return [...list]
+ const next = [...withoutSource]
+ next.splice(targetIndex + (after ? 1 : 0), 0, sourceId)
+ return next
+}
+
+function removeEmptyFolder(state: RailState, folderId: string): void {
+ if ((state.folders[folderId]?.length ?? 0) > 0) return
+ delete state.folders[folderId]
+ state.folderOrder = state.folderOrder.filter((id) => id !== folderId)
+ state.expanded = state.expanded.filter((id) => id !== folderId)
+}
+
+function removeServerFromFolder(state: RailState, serverId: string): string | null {
+ const folderId = folderForServer(state, serverId)
+ if (!folderId) return null
+ state.folders[folderId] = state.folders[folderId]!.filter((id) => id !== serverId)
+ removeEmptyFolder(state, folderId)
+ return folderId
+}
+
+function insertServerRelative(
+ state: RailState,
+ sourceId: string,
+ targetId: string,
+ after: boolean,
+): boolean {
+ const targetFolder = folderForServer(state, targetId)
+ const sourceFolder = folderForServer(state, sourceId)
+ if (sourceFolder === targetFolder) {
+ if (targetFolder) {
+ state.folders[targetFolder] = moveRelative(
+ state.folders[targetFolder]!,
+ sourceId,
+ targetId,
+ after,
+ )
+ } else {
+ state.serverOrder = moveRelative(state.serverOrder, sourceId, targetId, after)
+ }
+ return true
+ }
+
+ removeServerFromFolder(state, sourceId)
+ if (targetFolder) {
+ const targetItems = state.folders[targetFolder]
+ if (!targetItems) return false
+ state.folders[targetFolder] = moveRelative(
+ [...targetItems, sourceId],
+ sourceId,
+ targetId,
+ after,
+ )
+ state.expanded = unique([...state.expanded, targetFolder])
+ return true
+ }
+
+ state.serverOrder = moveRelative(state.serverOrder, sourceId, targetId, after)
+ return true
+}
+
+function combineServer(state: RailState, instruction: RailInstruction): CommitResult {
+ if (instruction.source.kind !== "server") {
+ return { state, applied: false, reason: "folders cannot combine" }
+ }
+ const sourceId = instruction.source.id
+ const sourceFolder = folderForServer(state, sourceId)
+
+ if (instruction.target.kind === "folder") {
+ const targetFolderId = instruction.target.id
+ const targetItems = state.folders[targetFolderId]
+ if (!targetItems) return { state, applied: false, reason: "target folder is missing" }
+ if (sourceFolder === targetFolderId) {
+ return { state, applied: false, reason: "server is already in target folder" }
+ }
+ removeServerFromFolder(state, sourceId)
+ state.folders[targetFolderId] = [...targetItems, sourceId]
+ state.expanded = unique([...state.expanded, targetFolderId])
+ return { state, applied: true }
+ }
+
+ const targetId = instruction.target.id
+ const targetFolder = folderForServer(state, targetId)
+ if (targetFolder) {
+ if (sourceFolder === targetFolder) {
+ return { state, applied: false, reason: "servers already share a folder" }
+ }
+ removeServerFromFolder(state, sourceId)
+ const targetItems = state.folders[targetFolder]
+ if (!targetItems) return { state, applied: false, reason: "target folder is missing" }
+ const targetIndex = targetItems.indexOf(targetId)
+ state.folders[targetFolder] = [...targetItems]
+ state.folders[targetFolder]!.splice(targetIndex + 1, 0, sourceId)
+ state.expanded = unique([...state.expanded, targetFolder])
+ return { state, applied: true }
+ }
+
+ if (sourceFolder) {
+ return {
+ state,
+ applied: false,
+ reason: "creating a folder requires two top-level servers",
+ }
+ }
+ if (state.folderOrder.length >= MAX_FOLDERS) {
+ return { state, applied: false, reason: "folder limit reached" }
+ }
+ const newFolderId = instruction.newFolderId
+ if (!newFolderId || state.folders[newFolderId]) {
+ return { state, applied: false, reason: "new folder id is required" }
+ }
+ state.folderOrder.push(newFolderId)
+ state.folders[newFolderId] = [sourceId, targetId]
+ state.expanded = unique([...state.expanded, newFolderId])
+ return { state, applied: true }
+}
+
+export function commitInstruction(
+ before: RailState,
+ instruction: RailInstruction,
+): CommitResult {
+ if (stateErrors(before).length > 0) {
+ return { state: before, applied: false, reason: "invalid start state" }
+ }
+ if (
+ instruction.source.kind === instruction.target.kind
+ && instruction.source.id === instruction.target.id
+ ) {
+ return { state: before, applied: false, reason: "source equals target" }
+ }
+
+ const next = cloneState(before)
+ let result: CommitResult
+ if (instruction.operation === "combine") {
+ result = combineServer(next, instruction)
+ } else if (instruction.source.kind === "folder" || instruction.target.kind === "folder") {
+ if (instruction.source.kind !== "folder" || instruction.target.kind !== "folder") {
+ return { state: before, applied: false, reason: "server and folder orders cannot interleave" }
+ }
+ if (!next.folderOrder.includes(instruction.source.id)
+ || !next.folderOrder.includes(instruction.target.id)) {
+ return { state: before, applied: false, reason: "folder is missing" }
+ }
+ next.folderOrder = moveRelative(
+ next.folderOrder,
+ instruction.source.id,
+ instruction.target.id,
+ instruction.operation === "reorder-after",
+ )
+ result = { state: next, applied: true }
+ } else {
+ if (!next.serverOrder.includes(instruction.source.id)
+ || !next.serverOrder.includes(instruction.target.id)) {
+ return { state: before, applied: false, reason: "server is missing" }
+ }
+ const applied = insertServerRelative(
+ next,
+ instruction.source.id,
+ instruction.target.id,
+ instruction.operation === "reorder-after",
+ )
+ result = applied
+ ? { state: next, applied: true }
+ : { state: before, applied: false, reason: "target is missing" }
+ }
+
+ if (!result.applied) return { ...result, state: before }
+ const errors = stateErrors(result.state)
+ if (errors.length > 0) {
+ return { state: before, applied: false, reason: errors.join("; ") }
+ }
+ if (sameState(before, result.state)) {
+ return { state: before, applied: false, reason: "instruction is a no-op" }
+ }
+ return result
+}
+
+function sameMembers(left: readonly string[], right: readonly string[]): boolean {
+ if (left.length !== right.length) return false
+ const set = new Set(left)
+ return right.every((value) => set.has(value))
+}
+
+export function planPersistence(
+ before: RailState,
+ after: RailState,
+ instruction: RailInstruction,
+): PersistenceCommand[] {
+ if (sameState(before, after)) return []
+ const commands: PersistenceCommand[] = []
+
+ if (!sameArray(before.serverOrder, after.serverOrder)) {
+ commands.push({ type: "reorder-servers", serverIds: [...after.serverOrder] })
+ }
+
+ const addedFolders = after.folderOrder.filter((folderId) => !before.folderOrder.includes(folderId))
+ const removedFolders = before.folderOrder.filter((folderId) => !after.folderOrder.includes(folderId))
+ if (addedFolders.length === 1 && instruction.operation === "combine") {
+ const folderId = addedFolders[0]!
+ commands.push({
+ type: "create-folder",
+ tempFolderId: folderId,
+ serverIds: [...after.folders[folderId]!],
+ })
+ }
+
+ for (const folderId of before.folderOrder) {
+ const beforeItems = before.folders[folderId] ?? []
+ const afterItems = after.folders[folderId]
+ if (!afterItems) {
+ commands.push({ type: "update-folder", folderId, serverIds: [] })
+ } else if (!sameArray(beforeItems, afterItems)) {
+ commands.push({ type: "update-folder", folderId, serverIds: [...afterItems] })
+ }
+ }
+
+ const sameFolderSet = sameMembers(before.folderOrder, after.folderOrder)
+ if (sameFolderSet && !sameArray(before.folderOrder, after.folderOrder)) {
+ commands.push({ type: "reorder-folders", folderIds: [...after.folderOrder] })
+ }
+
+ return commands
+}
+
+export function accessibleMoveLabel(
+ state: RailState,
+ instruction: RailInstruction,
+): string {
+ const source = instruction.source.kind === "server"
+ ? `Server ${instruction.source.id}`
+ : `Folder ${instruction.source.id}`
+ if (instruction.operation === "combine") {
+ const target = instruction.target.kind === "server"
+ ? `server ${instruction.target.id}`
+ : `folder ${instruction.target.id}`
+ return `${source} moved into ${target}`
+ }
+ const placement = instruction.operation === "reorder-before" ? "before" : "after"
+ const target = instruction.target.kind === "server"
+ ? `server ${instruction.target.id}`
+ : `folder ${instruction.target.id}`
+ const sourceFolder = instruction.source.kind === "server"
+ ? folderForServer(state, instruction.source.id)
+ : null
+ return `${source} moved ${placement} ${target}${sourceFolder ? ` from folder ${sourceFolder}` : ""}`
+}
diff --git a/spikes/server-rail-pdd/src/styles.css b/spikes/server-rail-pdd/src/styles.css
new file mode 100644
index 000000000..899abe2e8
--- /dev/null
+++ b/spikes/server-rail-pdd/src/styles.css
@@ -0,0 +1,182 @@
+:root {
+ color: #1c1917;
+ background: #f6f5f2;
+ font-family: Inter, ui-sans-serif, system-ui, sans-serif;
+ font-synthesis: none;
+ --card: #fff;
+ --border: #d6d3d1;
+ --muted: #78716c;
+ --accent: #2563eb;
+ --combine: #7c3aed;
+}
+
+* {
+ box-sizing: border-box;
+}
+
+body {
+ margin: 0;
+ min-width: 320px;
+}
+
+main {
+ width: min(720px, 100%);
+ margin: 0 auto;
+ padding: 24px;
+}
+
+h1 {
+ margin: 0 0 8px;
+ font-size: 24px;
+}
+
+#instructions {
+ color: var(--muted);
+ margin: 0 0 16px;
+}
+
+.controls {
+ display: flex;
+ gap: 8px;
+ margin-bottom: 12px;
+}
+
+button {
+ border: 1px solid var(--border);
+ border-radius: 8px;
+ background: var(--card);
+ color: inherit;
+ font: inherit;
+}
+
+button:focus-visible {
+ outline: 3px solid color-mix(in srgb, var(--accent) 45%, transparent);
+ outline-offset: 2px;
+}
+
+.controls button {
+ padding: 8px 12px;
+}
+
+.rail-scroll {
+ width: min(100%, 360px);
+ height: 460px;
+ overflow-y: auto;
+ overscroll-behavior: contain;
+ touch-action: pan-y;
+ scrollbar-width: thin;
+ border: 1px solid var(--border);
+ border-radius: 14px;
+ background: color-mix(in srgb, var(--card) 78%, transparent);
+ padding: 8px;
+}
+
+.folder {
+ display: contents;
+}
+
+.folder-children[hidden] {
+ display: none;
+}
+
+.rail-row {
+ position: relative;
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto;
+ gap: 8px;
+ min-height: 54px;
+ margin: 4px 0;
+ padding: 5px;
+ border: 2px solid transparent;
+ border-radius: 12px;
+ background: var(--card);
+ touch-action: pan-y;
+}
+
+.rail-row[data-level="1"] {
+ margin-left: 26px;
+}
+
+.primary-action,
+.move-trigger {
+ min-height: 40px;
+ padding: 8px 12px;
+}
+
+.primary-action {
+ cursor: grab;
+ text-align: left;
+ font-weight: 650;
+}
+
+.primary-action:active {
+ cursor: grabbing;
+}
+
+.preview-before::before,
+.preview-after::after {
+ content: "";
+ position: absolute;
+ z-index: 2;
+ right: 4px;
+ left: 4px;
+ height: 3px;
+ border-radius: 999px;
+ background: var(--accent);
+}
+
+.preview-before::before {
+ top: -5px;
+}
+
+.preview-after::after {
+ bottom: -5px;
+}
+
+.preview-combine {
+ border-color: var(--combine);
+ box-shadow: 0 0 0 2px color-mix(in srgb, var(--combine) 18%, transparent);
+}
+
+.move-menu {
+ grid-column: 1 / -1;
+ display: grid;
+ gap: 4px;
+ max-height: 180px;
+ overflow-y: auto;
+ scrollbar-width: thin;
+ border-top: 1px solid var(--border);
+ padding-top: 6px;
+}
+
+.move-menu[hidden] {
+ display: none;
+}
+
+.move-menu button {
+ padding: 7px 10px;
+ text-align: left;
+}
+
+#events {
+ min-height: 88px;
+ max-height: 240px;
+ overflow: auto;
+ margin-top: 16px;
+ border-radius: 12px;
+ background: #1c1917;
+ color: #fafaf9;
+ padding: 12px;
+ font-size: 12px;
+}
+
+@media (max-width: 520px) {
+ main {
+ padding: 12px;
+ }
+
+ .rail-scroll {
+ width: 100%;
+ height: 520px;
+ }
+}
diff --git a/spikes/server-rail-pdd/tests/rail-pdd.spec.ts b/spikes/server-rail-pdd/tests/rail-pdd.spec.ts
new file mode 100644
index 000000000..6e0c6e6b7
--- /dev/null
+++ b/spikes/server-rail-pdd/tests/rail-pdd.spec.ts
@@ -0,0 +1,208 @@
+import { expect, test, type Page } from "@playwright/test"
+
+type SpikeReadout = {
+ state: {
+ serverOrder: string[]
+ folderOrder: string[]
+ folders: Record<string, string[]>
+ expanded: string[]
+ }
+ events: Array<{ type: string; detail?: string; commands?: unknown[] }>
+ clickCount: number
+ commitCount: number
+ persistenceBatchCount: number
+ rollbackCount: number
+ preview: null | { operation: string; target: { kind: string; id: string } }
+}
+
+async function read(page: Page): Promise<SpikeReadout> {
+ return page.evaluate(() => window.__railSpike.read())
+}
+
+async function reset(page: Page): Promise<void> {
+ await page.getByTestId("reset").click()
+}
+
+async function pointerDrag(
+ page: Page,
+ sourceTestId: string,
+ targetTestId: string,
+ targetYRatio: number,
+): Promise<void> {
+ const sourceBox = await page.getByTestId(sourceTestId).boundingBox()
+ const targetBox = await page.getByTestId(targetTestId).boundingBox()
+ expect(sourceBox).not.toBeNull()
+ expect(targetBox).not.toBeNull()
+ await page.mouse.move(sourceBox!.x + sourceBox!.width / 2, sourceBox!.y + sourceBox!.height / 2)
+ await page.mouse.down()
+ await page.mouse.move(targetBox!.x + targetBox!.width / 2, targetBox!.y + targetBox!.height * targetYRatio, { steps: 12 })
+ await page.mouse.up()
+}
+
+test.beforeEach(async ({ page }) => {
+ await page.goto("/")
+})
+
+test.describe("desktop pointer contract", () => {
+ test.skip(({ isMobile }) => Boolean(isMobile))
+
+ test("click, reorder, combine, and rollback each settle once", async ({ page }) => {
+ const clickBox = await page.getByTestId("primary-server-a").boundingBox()
+ expect(clickBox).not.toBeNull()
+ await page.mouse.move(clickBox!.x + clickBox!.width / 2, clickBox!.y + clickBox!.height / 2)
+ await page.mouse.down()
+ await page.mouse.move(clickBox!.x + clickBox!.width / 2 + 2, clickBox!.y + clickBox!.height / 2 + 2)
+ await page.mouse.up()
+ expect((await read(page)).clickCount).toBe(1)
+ expect((await read(page)).commitCount).toBe(0)
+
+ await pointerDrag(page, "primary-server-a", "rail-item-server-b", 0.95)
+ await expect.poll(async () => (await read(page)).commitCount).toBe(1)
+ const reordered = await read(page)
+ expect(reordered.state.serverOrder.slice(0, 2)).toEqual(["b", "a"])
+ expect(reordered.persistenceBatchCount).toBe(1)
+ expect(reordered.events.filter((event) => event.type === "optimistic-commit")).toHaveLength(1)
+
+ await reset(page)
+ await pointerDrag(page, "primary-server-a", "rail-item-server-b", 0.5)
+ await expect.poll(async () => (await read(page)).commitCount).toBe(1)
+ const combined = await read(page)
+ const createdFolder = combined.state.folderOrder.find((id) => id.startsWith("temporary-"))
+ expect(createdFolder).toBeTruthy()
+ expect(combined.state.folders[createdFolder!]).toEqual(["a", "b"])
+ expect(combined.events.find((event) => event.type === "optimistic-commit")?.commands).toEqual([
+ { type: "create-folder", tempFolderId: createdFolder, serverIds: ["a", "b"] },
+ ])
+
+ await reset(page)
+ await page.getByTestId("fail-next").click()
+ await page.getByTestId("move-trigger-server-a").click()
+ await page.getByTestId("move-server-a-reorder-after-b").click()
+ await expect.poll(async () => (await read(page)).rollbackCount).toBe(1)
+ const rolledBack = await read(page)
+ expect(rolledBack.state.serverOrder.slice(0, 2)).toEqual(["a", "b"])
+ expect(rolledBack.commitCount).toBe(1)
+ expect(rolledBack.persistenceBatchCount).toBe(1)
+ })
+
+ test("preview is non-mutating, collapsed folder hover expands, and Escape cancels", async ({ page }) => {
+ const before = await read(page)
+ const sourceBox = await page.getByTestId("primary-server-a").boundingBox()
+ const folderBox = await page.getByTestId("rail-item-folder-two").boundingBox()
+ expect(sourceBox).not.toBeNull()
+ expect(folderBox).not.toBeNull()
+
+ await page.mouse.move(sourceBox!.x + sourceBox!.width / 2, sourceBox!.y + sourceBox!.height / 2)
+ await page.mouse.down()
+ await page.mouse.move(folderBox!.x + folderBox!.width / 2, folderBox!.y + folderBox!.height / 2, { steps: 12 })
+ await expect(page.getByTestId("rail-item-folder-two")).toHaveClass(/preview-combine/)
+ expect((await read(page)).state).toEqual(before.state)
+ await page.waitForTimeout(200)
+ await page.mouse.move(8, 8, { steps: 6 })
+ await page.waitForTimeout(400)
+ await expect(page.locator('[data-folder-children="two"]')).toBeHidden()
+ const currentFolderBox = await page.getByTestId("rail-item-folder-two").boundingBox()
+ expect(currentFolderBox).not.toBeNull()
+ await page.mouse.move(currentFolderBox!.x + currentFolderBox!.width / 2, currentFolderBox!.y + currentFolderBox!.height / 2, { steps: 8 })
+ await page.waitForTimeout(550)
+ await expect(page.locator('[data-folder-children="two"]')).toBeVisible()
+ await page.screenshot({ path: "evidence/desktop-hover-combine.png", fullPage: true })
+ await page.keyboard.press("Escape")
+ await expect.poll(async () => (await read(page)).events.some((event) => event.type === "cancel")).toBe(true)
+ const after = await read(page)
+ expect(after.state).toEqual(before.state)
+ expect(after.commitCount).toBe(0)
+ expect(after.persistenceBatchCount).toBe(0)
+
+ const nextSourceBox = await page.getByTestId("primary-server-a").boundingBox()
+ expect(nextSourceBox).not.toBeNull()
+ await page.mouse.move(nextSourceBox!.x + nextSourceBox!.width / 2, nextSourceBox!.y + nextSourceBox!.height / 2)
+ await page.mouse.down()
+ await page.mouse.move(8, 8, { steps: 8 })
+ await page.mouse.up()
+ await expect.poll(async () => (await read(page)).events.filter((event) => event.type === "cancel").length).toBe(2)
+ expect((await read(page)).commitCount).toBe(0)
+ })
+
+ test("edge drag auto-scrolls while canonical state stays fixed until drop", async ({ page }) => {
+ const rail = page.getByTestId("rail-scroll")
+ const railBox = await rail.boundingBox()
+ const sourceBox = await page.getByTestId("primary-folder-one").boundingBox()
+ expect(railBox).not.toBeNull()
+ expect(sourceBox).not.toBeNull()
+
+ await page.mouse.move(railBox!.x + railBox!.width / 2, railBox!.y + railBox!.height / 2)
+ await page.mouse.wheel(0, 260)
+ await expect.poll(async () => rail.evaluate((element) => element.scrollTop)).toBeGreaterThan(0)
+ expect((await read(page)).commitCount).toBe(0)
+ await rail.evaluate((element) => { element.scrollTop = 0 })
+
+ await page.mouse.move(sourceBox!.x + sourceBox!.width / 2, sourceBox!.y + sourceBox!.height / 2)
+ await page.mouse.down()
+ await page.mouse.move(railBox!.x + railBox!.width / 2, railBox!.y + railBox!.height - 3, { steps: 16 })
+ await expect(page.locator('[data-folder-children="one"]')).toBeHidden()
+ await expect.poll(async () => rail.evaluate((element) => element.scrollTop), { timeout: 4_000 }).toBeGreaterThan(0)
+ expect((await read(page)).commitCount).toBe(0)
+ await page.keyboard.press("Escape")
+ await expect.poll(async () => (await read(page)).events.some((event) => event.type === "cancel")).toBe(true)
+ await expect(page.locator('[data-folder-children="one"]')).toBeVisible()
+ expect((await read(page)).commitCount).toBe(0)
+ })
+
+ test("Move menu preserves parity, announcement, and focus", async ({ page }) => {
+ await page.getByTestId("move-trigger-server-c").click()
+ await page.getByTestId("move-server-c-reorder-after-e").click()
+ await expect.poll(async () => (await read(page)).commitCount).toBe(1)
+ const moved = await read(page)
+ expect(moved.state.folders.one).toEqual(["d"])
+ expect(moved.state.folders.two).toEqual(["e", "c", "f"])
+ await expect(page.getByRole("status")).toHaveText("Server c moved after server e from folder one")
+ await expect(page.getByTestId("primary-server-c")).toBeFocused()
+ })
+})
+
+test.describe("mobile touch separation", () => {
+ test.skip(({ isMobile }) => !isMobile)
+
+ test("row swipe scrolls, short tap clicks once, and Move is intentional", async ({ page }) => {
+ const rail = page.getByTestId("rail-scroll")
+ const row = page.getByTestId("primary-server-g")
+ const rowBox = await row.boundingBox()
+ expect(rowBox).not.toBeNull()
+ const client = await page.context().newCDPSession(page)
+ const x = rowBox!.x + rowBox!.width / 2
+ const startY = rowBox!.y + rowBox!.height / 2
+
+ await client.send("Input.dispatchTouchEvent", {
+ type: "touchStart",
+ touchPoints: [{ x, y: startY }],
+ })
+ for (let index = 1; index <= 8; index += 1) {
+ await client.send("Input.dispatchTouchEvent", {
+ type: "touchMove",
+ touchPoints: [{ x, y: startY - index * 18 }],
+ })
+ }
+ await client.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] })
+ await expect.poll(async () => rail.evaluate((element) => element.scrollTop)).toBeGreaterThan(0)
+ let current = await read(page)
+ expect(current.commitCount).toBe(0)
+ expect(current.clickCount).toBe(0)
+
+ await rail.evaluate((element) => { element.scrollTop = 0 })
+ const tapBox = await page.getByTestId("primary-server-a").boundingBox()
+ expect(tapBox).not.toBeNull()
+ await page.touchscreen.tap(tapBox!.x + tapBox!.width / 2, tapBox!.y + tapBox!.height / 2)
+ await expect.poll(async () => (await read(page)).clickCount).toBe(1)
+ current = await read(page)
+ expect(current.commitCount).toBe(0)
+
+ await page.getByTestId("move-trigger-server-a").click()
+ await page.screenshot({ path: "evidence/mobile-move-menu.png", fullPage: true })
+ await page.getByTestId("move-server-a-into-two").click()
+ await expect.poll(async () => (await read(page)).commitCount).toBe(1)
+ current = await read(page)
+ expect(current.state.folders.two).toEqual(["e", "f", "a"])
+ expect(current.persistenceBatchCount).toBe(1)
+ })
+})
diff --git a/spikes/server-rail-pdd/tsconfig.json b/spikes/server-rail-pdd/tsconfig.json
new file mode 100644
index 000000000..ce7eb4a8b
--- /dev/null
+++ b/spikes/server-rail-pdd/tsconfig.json
@@ -0,0 +1,13 @@
+{
+ "compilerOptions": {
+ "target": "ES2023",
+ "useDefineForClassFields": true,
+ "module": "ESNext",
+ "moduleResolution": "Bundler",
+ "strict": true,
+ "noEmit": true,
+ "lib": ["ES2023", "DOM", "DOM.Iterable"],
+ "types": ["vitest/globals", "node"]
+ },
+ "include": ["src", "tests", "playwright.config.ts", "vite.config.ts"]
+}
diff --git a/spikes/server-rail-pdd/vite.config.ts b/spikes/server-rail-pdd/vite.config.ts
new file mode 100644
index 000000000..153005a3b
--- /dev/null
+++ b/spikes/server-rail-pdd/vite.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+ server: {
+ host: "127.0.0.1",
+ port: 4177,
+ strictPort: true,
+ },
+ test: {
+ include: ["src/**/*.test.ts"],
+ },
+})
diff --git a/src/shared/src/community-server-rail.test.ts b/src/shared/src/community-server-rail.test.ts
new file mode 100644
index 000000000..edc59042c
--- /dev/null
+++ b/src/shared/src/community-server-rail.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import {
+ projectServerRailCommit,
+ serverRailCommitRequestSchema,
+ type ServerRailState,
+} from "./community-server-rail";
+
+function snapshot(): ServerRailState {
+ return {
+ serverOrder: ["a", "b", "c", "d", "e"],
+ folderOrder: ["one", "two"],
+ folders: {
+ one: { id: "one", name: "One", serverIds: ["c", "d"] },
+ two: { id: "two", name: "Two", serverIds: ["e"] },
+ },
+ };
+}
+
+describe("server rail wire contract", () => {
+ it("is strict, bounded, and rejects duplicate semantic commands", () => {
+ expect(serverRailCommitRequestSchema.safeParse({ commands: [] }).success).toBe(false);
+ expect(serverRailCommitRequestSchema.safeParse({
+ commands: [{ kind: "delete-folder", folderId: "one", extra: true }],
+ }).success).toBe(false);
+
+ const result = projectServerRailCommit(snapshot(), {
+ commands: [
+ { kind: "replace-folder-items", folderId: "one", serverIds: ["c"] },
+ { kind: "delete-folder", folderId: "one" },
+ ],
+ }, () => "new");
+ expect(result).toEqual({ ok: false, error: "duplicate command for folder one", status: 400 });
+ });
+
+ it("projects a cross-folder move and identifies only affected resources", () => {
+ const result = projectServerRailCommit(snapshot(), {
+ commands: [
+ { kind: "replace-folder-items", folderId: "one", serverIds: ["d"] },
+ { kind: "replace-folder-items", folderId: "two", serverIds: ["e", "c"] },
+ ],
+ }, () => "new");
+ expect(result.ok).toBe(true);
+ if (!result.ok) return;
+ expect(result.value.after.folders.one.serverIds).toEqual(["d"]);
+ expect(result.value.after.folders.two.serverIds).toEqual(["e", "c"]);
+ expect(result.value.affectedFolderIds).toEqual(["one", "two"]);
+ expect(result.value.movedServerIds).toEqual(["c"]);
+ });
+
+ it("maps a client folder id and rejects duplicate folder membership", () => {
+ const created = projectServerRailCommit(snapshot(), {
+ commands: [{ kind: "create-folder", clientId: "tmp", name: "Group", serverIds: ["a", "b"] }],
+ }, () => "real");
+ expect(created.ok).toBe(true);
+ if (created.ok) {
+ expect(created.value.createdFolderIds).toEqual({ tmp: "real" });
+ expect(created.value.after.folders.real.serverIds).toEqual(["a", "b"]);
+ }
+
+ const duplicate = projectServerRailCommit(snapshot(), {
+ commands: [{ kind: "replace-folder-items", folderId: "two", serverIds: ["e", "c"] }],
+ }, () => "new");
+ expect(duplicate).toMatchObject({ ok: false, error: "server c belongs to multiple folders" });
+ });
+
+ it("accepts a complete 101+ membership reorder without a cardinality cliff", () => {
+ const ids = Array.from({ length: 125 }, (_, index) => `server-${index}`);
+ const state: ServerRailState = { serverOrder: ids, folderOrder: [], folders: {} };
+ const result = projectServerRailCommit(state, {
+ commands: [{ kind: "reorder-servers", serverIds: [...ids].reverse() }],
+ }, () => "unused");
+ expect(result.ok).toBe(true);
+ if (result.ok) expect(result.value.after.serverOrder).toEqual([...ids].reverse());
+ });
+
+ it("requires complete reorder sets and rejects no-ops", () => {
+ expect(projectServerRailCommit(snapshot(), {
+ commands: [{ kind: "reorder-servers", serverIds: ["a", "b"] }],
+ }, () => "new")).toMatchObject({ ok: false, error: "serverIds must match current memberships" });
+
+ expect(projectServerRailCommit(snapshot(), {
+ commands: [{ kind: "reorder-folders", folderIds: ["one", "two"] }],
+ }, () => "new")).toMatchObject({ ok: false, error: "rail command is a no-op" });
+ });
+});
diff --git a/src/shared/src/community-server-rail.ts b/src/shared/src/community-server-rail.ts
new file mode 100644
index 000000000..9219e599b
--- /dev/null
+++ b/src/shared/src/community-server-rail.ts
@@ -0,0 +1,280 @@
+import { z } from "zod";
+import { MAX_FOLDER_NAME_LENGTH } from "./constants/community";
+
+export const MAX_SERVER_RAIL_COMMANDS = 3;
+export const MAX_SERVER_RAIL_FOLDERS = 10;
+export const MAX_SERVER_RAIL_REQUEST_BYTES = 1_000_000;
+export const SERVER_RAIL_SNAPSHOT_STATEMENTS = 3;
+export const SERVER_RAIL_MAX_WRITE_STATEMENTS = 13;
+
+const idSchema = z.string().trim().min(1);
+const idsSchema = z.array(idSchema);
+
+const reorderServersSchema = z.strictObject({
+ kind: z.literal("reorder-servers"),
+ serverIds: idsSchema,
+});
+const reorderFoldersSchema = z.strictObject({
+ kind: z.literal("reorder-folders"),
+ folderIds: idsSchema,
+});
+const replaceFolderItemsSchema = z.strictObject({
+ kind: z.literal("replace-folder-items"),
+ folderId: idSchema,
+ serverIds: idsSchema.min(1),
+});
+const deleteFolderSchema = z.strictObject({
+ kind: z.literal("delete-folder"),
+ folderId: idSchema,
+});
+const createFolderSchema = z.strictObject({
+ kind: z.literal("create-folder"),
+ clientId: idSchema,
+ name: z.string().trim().min(1).max(MAX_FOLDER_NAME_LENGTH),
+ serverIds: idsSchema.min(1),
+});
+
+export const serverRailCommandSchema = z.discriminatedUnion("kind", [
+ reorderServersSchema,
+ reorderFoldersSchema,
+ replaceFolderItemsSchema,
+ deleteFolderSchema,
+ createFolderSchema,
+]);
+
+export const serverRailCommitRequestSchema = z.strictObject({
+ commands: z.array(serverRailCommandSchema).min(1).max(MAX_SERVER_RAIL_COMMANDS),
+});
+
+export type ServerRailCommand = z.infer<typeof serverRailCommandSchema>;
+export type ServerRailCommitRequest = z.infer<typeof serverRailCommitRequestSchema>;
+
+export type ServerRailCommitResponse = {
+ createdFolderIds: Record<string, string>;
+};
+
+export type ServerRailFolderState = {
+ id: string;
+ name: string;
+ serverIds: string[];
+};
+
+export type ServerRailState = {
+ serverOrder: string[];
+ folderOrder: string[];
+ folders: Record<string, ServerRailFolderState>;
+};
+
+export type ServerRailProjection = {
+ before: ServerRailState;
+ after: ServerRailState;
+ affectedFolderIds: string[];
+ movedServerIds: string[];
+ createdFolders: ServerRailFolderState[];
+ deletedFolderIds: string[];
+ reorderServers: boolean;
+ reorderFolders: boolean;
+ createdFolderIds: Record<string, string>;
+};
+
+export type ServerRailProjectionResult =
+ | { ok: true; value: ServerRailProjection }
+ | { ok: false; error: string; status: 400 | 404 };
+
+function cloneState(state: ServerRailState): ServerRailState {
+ return {
+ serverOrder: [...state.serverOrder],
+ folderOrder: [...state.folderOrder],
+ folders: Object.fromEntries(
+ Object.entries(state.folders).map(([id, folder]) => [
+ id,
+ { ...folder, serverIds: [...folder.serverIds] },
+ ]),
+ ),
+ };
+}
+
+function hasDuplicates(values: readonly string[]): boolean {
+ return new Set(values).size !== values.length;
+}
+
+function sameArray(left: readonly string[], right: readonly string[]): boolean {
+ return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function sameSet(left: readonly string[], right: readonly string[]): boolean {
+ return left.length === right.length && new Set(left).size === left.length
+ && right.every((value) => left.includes(value));
+}
+
+function parentByServer(state: ServerRailState): Map<string, string | null> {
+ const parents = new Map<string, string | null>(
+ state.serverOrder.map((serverId) => [serverId, null]),
+ );
+ for (const folderId of state.folderOrder) {
+ for (const serverId of state.folders[folderId]?.serverIds ?? []) {
+ parents.set(serverId, folderId);
+ }
+ }
+ return parents;
+}
+
+function validateFinalState(
+ state: ServerRailState,
+ options: { allowFolderOverflow?: boolean } = {},
+): string | null {
+ if (hasDuplicates(state.serverOrder)) return "serverIds must be unique";
+ if (hasDuplicates(state.folderOrder)) return "folderIds must be unique";
+ if (!options.allowFolderOverflow && state.folderOrder.length > MAX_SERVER_RAIL_FOLDERS) {
+ return "folder limit reached";
+ }
+ const membershipIds = new Set(state.serverOrder);
+ const claimed = new Set<string>();
+ for (const folderId of state.folderOrder) {
+ const folder = state.folders[folderId];
+ if (!folder) return `folder ${folderId} not found`;
+ if (folder.serverIds.length === 0) return `folder ${folderId} must not be empty`;
+ if (hasDuplicates(folder.serverIds)) return `folder ${folderId} contains duplicate servers`;
+ for (const serverId of folder.serverIds) {
+ if (!membershipIds.has(serverId)) return `not a member of server ${serverId}`;
+ if (claimed.has(serverId)) return `server ${serverId} belongs to multiple folders`;
+ claimed.add(serverId);
+ }
+ }
+ if (Object.keys(state.folders).some((folderId) => !state.folderOrder.includes(folderId))) {
+ return "folder state contains unordered folders";
+ }
+ return null;
+}
+
+function sameState(left: ServerRailState, right: ServerRailState): boolean {
+ if (!sameArray(left.serverOrder, right.serverOrder)) return false;
+ if (!sameArray(left.folderOrder, right.folderOrder)) return false;
+ return left.folderOrder.every((folderId) => {
+ const a = left.folders[folderId];
+ const b = right.folders[folderId];
+ return a?.name === b?.name && sameArray(a?.serverIds ?? [], b?.serverIds ?? []);
+ });
+}
+
+export function projectServerRailCommit(
+ snapshot: ServerRailState,
+ request: ServerRailCommitRequest,
+ createFolderId: (clientId: string) => string,
+): ServerRailProjectionResult {
+ const recoveringFolderOverflow = snapshot.folderOrder.length > MAX_SERVER_RAIL_FOLDERS;
+ const beforeError = validateFinalState(snapshot, {
+ allowFolderOverflow: recoveringFolderOverflow,
+ });
+ if (beforeError) return { ok: false, error: `invalid current rail: ${beforeError}`, status: 400 };
+ if (
+ recoveringFolderOverflow
+ && request.commands.some((command) => command.kind !== "delete-folder")
+ ) {
+ return { ok: false, error: "folder limit recovery only permits deleting folders", status: 400 };
+ }
+
+ const after = cloneState(snapshot);
+ const affectedFolderIds = new Set<string>();
+ const deletedFolderIds = new Set<string>();
+ const createdFolders: ServerRailFolderState[] = [];
+ const createdFolderIds: Record<string, string> = {};
+ const commandResources = new Set<string>();
+ let reorderServers = false;
+ let reorderFolders = false;
+ let existingFolderMutations = 0;
+ let createCount = 0;
+
+ for (const command of request.commands) {
+ if (command.kind === "reorder-servers") {
+ if (reorderServers) return { ok: false, error: "duplicate reorder-servers command", status: 400 };
+ if (!sameSet(command.serverIds, snapshot.serverOrder)) {
+ return { ok: false, error: "serverIds must match current memberships", status: 400 };
+ }
+ after.serverOrder = [...command.serverIds];
+ reorderServers = true;
+ continue;
+ }
+
+ if (command.kind === "reorder-folders") {
+ if (reorderFolders) return { ok: false, error: "duplicate reorder-folders command", status: 400 };
+ after.folderOrder = [...command.folderIds];
+ reorderFolders = true;
+ continue;
+ }
+
+ if (command.kind === "create-folder") {
+ createCount += 1;
+ if (createCount > 1 || createdFolderIds[command.clientId]) {
+ return { ok: false, error: "duplicate create-folder command", status: 400 };
+ }
+ const id = createFolderId(command.clientId);
+ if (!id || after.folders[id]) return { ok: false, error: "invalid created folder id", status: 400 };
+ const folder = { id, name: command.name, serverIds: [...command.serverIds] };
+ createdFolderIds[command.clientId] = id;
+ createdFolders.push(folder);
+ after.folders[id] = folder;
+ after.folderOrder.push(id);
+ continue;
+ }
+
+ const resource = `folder:${command.folderId}`;
+ if (commandResources.has(resource)) {
+ return { ok: false, error: `duplicate command for folder ${command.folderId}`, status: 400 };
+ }
+ commandResources.add(resource);
+ existingFolderMutations += 1;
+ if (existingFolderMutations > 2) {
+ return { ok: false, error: "too many folder mutations", status: 400 };
+ }
+ if (!snapshot.folders[command.folderId]) {
+ return { ok: false, error: `folder ${command.folderId} not found`, status: 404 };
+ }
+ affectedFolderIds.add(command.folderId);
+ if (command.kind === "delete-folder") {
+ delete after.folders[command.folderId];
+ after.folderOrder = after.folderOrder.filter((id) => id !== command.folderId);
+ deletedFolderIds.add(command.folderId);
+ } else {
+ after.folders[command.folderId] = {
+ ...after.folders[command.folderId]!,
+ serverIds: [...command.serverIds],
+ };
+ }
+ }
+
+ if (reorderFolders && !sameSet(after.folderOrder, Object.keys(after.folders))) {
+ return { ok: false, error: "folderIds must match post-command folders", status: 400 };
+ }
+
+ const folderCountImproved = after.folderOrder.length < snapshot.folderOrder.length;
+ if (recoveringFolderOverflow && !folderCountImproved) {
+ return { ok: false, error: "folder limit recovery must reduce the folder count", status: 400 };
+ }
+ const afterError = validateFinalState(after, {
+ allowFolderOverflow: recoveringFolderOverflow && folderCountImproved,
+ });
+ if (afterError) return { ok: false, error: afterError, status: afterError.includes("not found") ? 404 : 400 };
+ if (sameState(snapshot, after)) return { ok: false, error: "rail command is a no-op", status: 400 };
+
+ const beforeParents = parentByServer(snapshot);
+ const afterParents = parentByServer(after);
+ const movedServerIds = after.serverOrder.filter(
+ (serverId) => beforeParents.get(serverId) !== afterParents.get(serverId),
+ );
+
+ return {
+ ok: true,
+ value: {
+ before: cloneState(snapshot),
+ after,
+ affectedFolderIds: [...affectedFolderIds],
+ movedServerIds,
+ createdFolders,
+ deletedFolderIds: [...deletedFolderIds],
+ reorderServers,
+ reorderFolders,
+ createdFolderIds,
+ },
+ };
+}
diff --git a/src/shared/src/db/queries-index.ts b/src/shared/src/db/queries-index.ts
index 9afa497b1..e14b07e4c 100644
--- a/src/shared/src/db/queries-index.ts
+++ b/src/shared/src/db/queries-index.ts
@@ -53,6 +53,7 @@ export * as communitySearch from "./queries/community/search";
export * as communityNotificationSetting from "./queries/community/notification-setting";
export * as communityNotificationEligibility from "./queries/community/notification-eligibility";
export * as communityServerFolder from "./queries/community/server-folder";
+export * as communityServerRail from "./queries/community/server-rail";
export * as communityInbox from "./queries/community/inbox";
export * as communityMachine from "./queries/community/machine";
export * as communityMachineSession from "./queries/community/machine-session-epoch";
diff --git a/src/shared/src/db/queries/community/member.ts b/src/shared/src/db/queries/community/member.ts
index 4bbc26888..c76571cff 100644
--- a/src/shared/src/db/queries/community/member.ts
+++ b/src/shared/src/db/queries/community/member.ts
@@ -1,5 +1,10 @@
import { eq, and, ne, inArray, count, asc, or, gt, isNull, sql } from "drizzle-orm";
-import { communityServerMember, communityUserProfile } from "../../community-schema";
+import {
+ communityServerFolder,
+ communityServerFolderItem,
+ communityServerMember,
+ communityUserProfile,
+} from "../../community-schema";
import { user } from "../../schema";
import type { Database } from "../../index";
import {
@@ -43,8 +48,36 @@ export async function removeMemberAndOwnerBots(
db: Database,
memberId: string,
serverId: string,
+ targetUserId: string,
botUserIds: string[],
) {
+ const removedUserIds = [...new Set([targetUserId, ...botUserIds])];
+ const cleanupFolderItems = db
+ .delete(communityServerFolderItem)
+ .where(and(
+ eq(communityServerFolderItem.serverId, serverId),
+ sql`EXISTS (
+ SELECT 1
+ FROM ${communityServerFolder}
+ JOIN json_each(${JSON.stringify(removedUserIds)}) AS removed_user
+ ON CAST(removed_user.value AS TEXT) = ${communityServerFolder.userId}
+ WHERE ${communityServerFolder.id} = ${communityServerFolderItem.folderId}
+ )`,
+ ));
+ const cleanupEmptyFolders = db
+ .delete(communityServerFolder)
+ .where(and(
+ sql`EXISTS (
+ SELECT 1
+ FROM json_each(${JSON.stringify(removedUserIds)}) AS removed_user
+ WHERE CAST(removed_user.value AS TEXT) = ${communityServerFolder.userId}
+ )`,
+ sql`NOT EXISTS (
+ SELECT 1
+ FROM ${communityServerFolderItem}
+ WHERE ${communityServerFolderItem.folderId} = ${communityServerFolder.id}
+ )`,
+ ));
const removeTarget = db
.delete(communityServerMember)
.where(
@@ -55,8 +88,13 @@ export async function removeMemberAndOwnerBots(
)
.returning();
const removeBots = removeOwnerBotsFromServerStatement(db, serverId, botUserIds);
- const results = (await db.batch([removeTarget, removeBots] as any)) as any[];
- return (results[0] as Array<typeof communityServerMember.$inferSelect>)[0] ?? null;
+ const results = (await db.batch([
+ cleanupFolderItems,
+ cleanupEmptyFolders,
+ removeTarget,
+ removeBots,
+ ] as any)) as any[];
+ return (results[2] as Array<typeof communityServerMember.$inferSelect>)[0] ?? null;
}
export async function updateRole(db: Database, memberId: string, role: string) {
@@ -399,7 +437,7 @@ export async function getMemberships(db: Database, userId: string, serverIds: st
/**
* Owner-leaves-server cascade — SELECT the bot userIds that will be removed
* from `serverId` because their owner is leaving. Called as step 1 of the
- * three-step leave/kick sequence (see §Owner-leaves-server in plan).
+ * leave/kick sequence (see §Owner-leaves-server in plan).
*/
export async function listOwnerBotsInServer(
db: Database,
@@ -443,12 +481,14 @@ export function removeOwnerBotsFromServerStatement(
}
return db
.delete(communityServerMember)
- .where(
- and(
- eq(communityServerMember.serverId, serverId),
- inArray(communityServerMember.userId, botUserIds)
- )
- );
+ .where(and(
+ eq(communityServerMember.serverId, serverId),
+ sql`EXISTS (
+ SELECT 1
+ FROM json_each(${JSON.stringify(botUserIds)}) AS removed_bot
+ WHERE CAST(removed_bot.value AS TEXT) = ${communityServerMember.userId}
+ )`,
+ ));
}
/** Executes `removeOwnerBotsFromServerStatement` — one DELETE for all bots. */
diff --git a/src/shared/src/db/queries/community/server-rail.ts b/src/shared/src/db/queries/community/server-rail.ts
new file mode 100644
index 000000000..2423df06c
--- /dev/null
+++ b/src/shared/src/db/queries/community/server-rail.ts
@@ -0,0 +1,440 @@
+import { and, asc, eq, sql } from "drizzle-orm";
+import { alias } from "drizzle-orm/sqlite-core";
+import type { ServerRailProjection, ServerRailState } from "../../../community-server-rail";
+import {
+ MAX_SERVER_RAIL_FOLDERS,
+ SERVER_RAIL_MAX_WRITE_STATEMENTS,
+} from "../../../community-server-rail";
+import {
+ communityServerFolder,
+ communityServerFolderItem,
+ communityServerMember,
+} from "../../community-schema";
+import type { Database } from "../../index";
+
+export async function readServerRailSnapshot(
+ db: Database,
+ userId: string,
+): Promise<ServerRailState> {
+ const currentMember = alias(communityServerMember, "current_member");
+ const memberships = db
+ .select({ serverId: communityServerMember.serverId })
+ .from(communityServerMember)
+ .where(eq(communityServerMember.userId, userId))
+ .orderBy(
+ asc(communityServerMember.railOrder),
+ asc(communityServerMember.joinedAt),
+ asc(communityServerMember.serverId),
+ );
+ const folders = db
+ .select({
+ id: communityServerFolder.id,
+ name: communityServerFolder.name,
+ })
+ .from(communityServerFolder)
+ .where(eq(communityServerFolder.userId, userId))
+ .orderBy(
+ asc(sql`COALESCE(${communityServerFolder.position}, 0)`),
+ asc(communityServerFolder.id),
+ );
+ const items = db
+ .select({
+ folderId: communityServerFolderItem.folderId,
+ serverId: communityServerFolderItem.serverId,
+ })
+ .from(communityServerFolderItem)
+ .innerJoin(
+ communityServerFolder,
+ eq(communityServerFolder.id, communityServerFolderItem.folderId),
+ )
+ .innerJoin(
+ currentMember,
+ and(
+ eq(currentMember.serverId, communityServerFolderItem.serverId),
+ eq(currentMember.userId, userId),
+ ),
+ )
+ .where(eq(communityServerFolder.userId, userId))
+ .orderBy(
+ asc(sql`COALESCE(${communityServerFolder.position}, 0)`),
+ asc(communityServerFolder.id),
+ asc(communityServerFolderItem.position),
+ asc(communityServerFolderItem.serverId),
+ );
+
+ const [membershipRows, folderRows, itemRows] = await db.batch([
+ memberships,
+ folders,
+ items,
+ ] as any) as unknown as [
+ Array<{ serverId: string }>,
+ Array<{ id: string; name: string }>,
+ Array<{ folderId: string; serverId: string }>,
+ ];
+
+ const claimedServerIds = new Set<string>();
+ const projectedItemRows = itemRows.filter((row) => {
+ if (claimedServerIds.has(row.serverId)) return false;
+ claimedServerIds.add(row.serverId);
+ return true;
+ });
+ const projectedFolderIds = new Set(projectedItemRows.map((row) => row.folderId));
+ const projectedFolderRows = folderRows.filter((row) => projectedFolderIds.has(row.id));
+ const state: ServerRailState = {
+ serverOrder: membershipRows.map((row) => row.serverId),
+ folderOrder: projectedFolderRows.map((row) => row.id),
+ folders: Object.fromEntries(projectedFolderRows.map((row) => [
+ row.id,
+ { id: row.id, name: row.name, serverIds: [] },
+ ])),
+ };
+ for (const item of projectedItemRows) {
+ state.folders[item.folderId]?.serverIds.push(item.serverId);
+ }
+ return state;
+}
+
+function idListCte(db: Database, alias: string, ids: readonly string[]) {
+ return db.$with(alias).as(
+ db.select({
+ id: sql<string>`CAST(value AS TEXT)`.as("id"),
+ position: sql<number>`CAST(key AS INTEGER)`.as("position"),
+ }).from(sql`json_each(${JSON.stringify(ids)})`),
+ );
+}
+
+function membershipReorderStatement(
+ db: Database,
+ userId: string,
+ serverIds: readonly string[],
+) {
+ const desired = idListCte(db, "desired_member_order", serverIds);
+ return db.with(desired)
+ .update(communityServerMember)
+ .set({
+ railOrder: sql<number>`(
+ SELECT ${desired.position}
+ FROM ${desired}
+ WHERE ${desired.id} = ${communityServerMember.serverId}
+ )`,
+ })
+ .where(and(
+ eq(communityServerMember.userId, userId),
+ sql`EXISTS (
+ SELECT 1 FROM ${desired}
+ WHERE ${desired.id} = ${communityServerMember.serverId}
+ )`,
+ ));
+}
+
+function folderReorderStatement(
+ db: Database,
+ userId: string,
+ folderIds: readonly string[],
+) {
+ const desired = idListCte(db, "desired_folder_order", folderIds);
+ return db.with(desired)
+ .update(communityServerFolder)
+ .set({
+ position: sql<number>`(
+ SELECT ${desired.position}
+ FROM ${desired}
+ WHERE ${desired.id} = ${communityServerFolder.id}
+ )`,
+ })
+ .where(and(
+ eq(communityServerFolder.userId, userId),
+ sql`EXISTS (
+ SELECT 1 FROM ${desired}
+ WHERE ${desired.id} = ${communityServerFolder.id}
+ )`,
+ ));
+}
+
+function createFolderStatement(
+ db: Database,
+ userId: string,
+ folder: { id: string; name: string },
+) {
+ const candidate = db.select({
+ id: sql<string>`${folder.id}`.as("id"),
+ userId: sql<string>`${userId}`.as("user_id"),
+ name: sql<string>`${folder.name}`.as("name"),
+ position: sql<number>`(
+ SELECT COALESCE(MAX(${communityServerFolder.position}), -1) + 1
+ FROM ${communityServerFolder}
+ WHERE ${communityServerFolder.userId} = ${userId}
+ )`.as("position"),
+ }).from(sql`(SELECT 1)`)
+ .where(sql`(
+ SELECT COUNT(*)
+ FROM ${communityServerFolder}
+ WHERE ${communityServerFolder.userId} = ${userId}
+ ) < ${MAX_SERVER_RAIL_FOLDERS}`);
+ return db.insert(communityServerFolder).select(candidate);
+}
+
+function globalReassignedItemCleanupStatement(
+ db: Database,
+ userId: string,
+ serverIds: readonly string[],
+) {
+ const moved = idListCte(db, "moved_server_ids", serverIds);
+ return db.with(moved)
+ .delete(communityServerFolderItem)
+ .where(and(
+ sql`EXISTS (
+ SELECT 1 FROM ${moved}
+ WHERE ${moved.id} = ${communityServerFolderItem.serverId}
+ )`,
+ sql`EXISTS (
+ SELECT 1 FROM ${communityServerFolder}
+ WHERE ${communityServerFolder.id} = ${communityServerFolderItem.folderId}
+ AND ${communityServerFolder.userId} = ${userId}
+ )`,
+ ));
+}
+
+function clearAffectedFolderItemsStatement(
+ db: Database,
+ userId: string,
+ folderIds: readonly string[],
+) {
+ const affected = idListCte(db, "affected_folder_ids", folderIds);
+ return db.with(affected)
+ .delete(communityServerFolderItem)
+ .where(and(
+ sql`EXISTS (
+ SELECT 1 FROM ${affected}
+ WHERE ${affected.id} = ${communityServerFolderItem.folderId}
+ )`,
+ sql`EXISTS (
+ SELECT 1 FROM ${communityServerFolder}
+ WHERE ${communityServerFolder.id} = ${communityServerFolderItem.folderId}
+ AND ${communityServerFolder.userId} = ${userId}
+ )`,
+ ));
+}
+
+function deleteFoldersStatement(
+ db: Database,
+ userId: string,
+ folderIds: readonly string[],
+) {
+ const deleted = idListCte(db, "deleted_folder_ids", folderIds);
+ return db.with(deleted)
+ .delete(communityServerFolder)
+ .where(and(
+ eq(communityServerFolder.userId, userId),
+ sql`EXISTS (
+ SELECT 1 FROM ${deleted}
+ WHERE ${deleted.id} = ${communityServerFolder.id}
+ )`,
+ ));
+}
+
+function deleteEmptyFoldersStatement(db: Database, userId: string) {
+ return db.delete(communityServerFolder)
+ .where(and(
+ eq(communityServerFolder.userId, userId),
+ sql`NOT EXISTS (
+ SELECT 1 FROM ${communityServerFolderItem}
+ WHERE ${communityServerFolderItem.folderId} = ${communityServerFolder.id}
+ )`,
+ ));
+}
+
+function deleteDanglingFolderItemsStatement(db: Database, userId: string) {
+ return db.delete(communityServerFolderItem)
+ .where(and(
+ sql`EXISTS (
+ SELECT 1 FROM ${communityServerFolder}
+ WHERE ${communityServerFolder.id} = ${communityServerFolderItem.folderId}
+ AND ${communityServerFolder.userId} = ${userId}
+ )`,
+ sql`NOT EXISTS (
+ SELECT 1 FROM ${communityServerMember}
+ WHERE ${communityServerMember.serverId} = ${communityServerFolderItem.serverId}
+ AND ${communityServerMember.userId} = ${userId}
+ )`,
+ ));
+}
+
+function deleteDuplicateFolderItemsStatement(db: Database, userId: string) {
+ return db.delete(communityServerFolderItem)
+ .where(sql`EXISTS (
+ SELECT 1
+ FROM community_server_folder_item AS preferred_item
+ INNER JOIN community_server_folder AS preferred_folder
+ ON preferred_folder.id = preferred_item.folder_id
+ INNER JOIN community_server_folder AS current_folder
+ ON current_folder.id = ${communityServerFolderItem.folderId}
+ WHERE preferred_item.server_id = ${communityServerFolderItem.serverId}
+ AND preferred_folder.user_id = ${userId}
+ AND current_folder.user_id = ${userId}
+ AND (
+ COALESCE(preferred_folder.position, 0) < COALESCE(current_folder.position, 0)
+ OR (
+ COALESCE(preferred_folder.position, 0) = COALESCE(current_folder.position, 0)
+ AND preferred_folder.id < current_folder.id
+ )
+ )
+ )`);
+}
+
+function insertFolderItemsStatement(
+ db: Database,
+ userId: string,
+ rows: Array<{ folderId: string; serverId: string; position: number }>,
+) {
+ const desired = db.$with("desired_folder_items").as(
+ db.select({
+ folderId: sql<string>`CAST(json_extract(value, '$.folderId') AS TEXT)`.as("folder_id"),
+ serverId: sql<string>`CAST(json_extract(value, '$.serverId') AS TEXT)`.as("server_id"),
+ position: sql<number>`CAST(json_extract(value, '$.position') AS INTEGER)`.as("position"),
+ }).from(sql`json_each(${JSON.stringify(rows)})`),
+ );
+ const ownedFolder = alias(communityServerFolder, "owned_folder");
+ const ownedMember = alias(communityServerMember, "owned_member");
+ const desiredFolderId = sql<string>`"desired_folder_items"."folder_id"`;
+ const desiredServerId = sql<string>`"desired_folder_items"."server_id"`;
+ const desiredPosition = sql<number>`"desired_folder_items"."position"`.as("position");
+ const selected = db.select({
+ folderId: ownedFolder.id,
+ serverId: ownedMember.serverId,
+ position: desiredPosition,
+ })
+ .from(desired)
+ .leftJoin(
+ ownedFolder,
+ and(eq(ownedFolder.id, desiredFolderId), eq(ownedFolder.userId, userId)),
+ )
+ .leftJoin(
+ ownedMember,
+ and(eq(ownedMember.serverId, desiredServerId), eq(ownedMember.userId, userId)),
+ );
+ return db.with(desired).insert(communityServerFolderItem).select(selected);
+}
+
+function normalizeFolderPositionsStatement(db: Database, userId: string) {
+ const ranked = db.$with("ranked_folders").as(
+ db.select({
+ id: communityServerFolder.id,
+ position: sql<number>`ROW_NUMBER() OVER (
+ ORDER BY COALESCE(${communityServerFolder.position}, 0), ${communityServerFolder.id}
+ ) - 1`.as("position"),
+ })
+ .from(communityServerFolder)
+ .where(eq(communityServerFolder.userId, userId)),
+ );
+ return db.with(ranked)
+ .update(communityServerFolder)
+ .set({
+ position: sql<number>`(
+ SELECT ${ranked.position} FROM ${ranked}
+ WHERE ${ranked.id} = ${communityServerFolder.id}
+ )`,
+ })
+ .where(and(
+ eq(communityServerFolder.userId, userId),
+ sql`EXISTS (SELECT 1 FROM ${ranked} WHERE ${ranked.id} = ${communityServerFolder.id})`,
+ ));
+}
+
+function normalizeFolderItemPositionsStatement(db: Database, userId: string) {
+ const ranked = db.$with("ranked_folder_items").as(
+ db.select({
+ folderId: communityServerFolderItem.folderId,
+ serverId: communityServerFolderItem.serverId,
+ position: sql<number>`ROW_NUMBER() OVER (
+ PARTITION BY ${communityServerFolderItem.folderId}
+ ORDER BY COALESCE(${communityServerFolderItem.position}, 0), ${communityServerFolderItem.serverId}
+ ) - 1`.as("position"),
+ })
+ .from(communityServerFolderItem)
+ .innerJoin(
+ communityServerFolder,
+ eq(communityServerFolder.id, communityServerFolderItem.folderId),
+ )
+ .where(eq(communityServerFolder.userId, userId)),
+ );
+ return db.with(ranked)
+ .update(communityServerFolderItem)
+ .set({
+ position: sql<number>`(
+ SELECT ${ranked.position} FROM ${ranked}
+ WHERE ${ranked.folderId} = ${communityServerFolderItem.folderId}
+ AND ${ranked.serverId} = ${communityServerFolderItem.serverId}
+ )`,
+ })
+ .where(sql`EXISTS (
+ SELECT 1 FROM ${ranked}
+ WHERE ${ranked.folderId} = ${communityServerFolderItem.folderId}
+ AND ${ranked.serverId} = ${communityServerFolderItem.serverId}
+ )`);
+}
+
+export function buildServerRailWriteStatements(
+ db: Database,
+ userId: string,
+ projection: ServerRailProjection,
+) {
+ const statements: any[] = [
+ deleteDanglingFolderItemsStatement(db, userId),
+ deleteDuplicateFolderItemsStatement(db, userId),
+ deleteEmptyFoldersStatement(db, userId),
+ ];
+ const itemFolderIds = new Set([
+ ...projection.affectedFolderIds.filter((id) => !projection.deletedFolderIds.includes(id)),
+ ...projection.createdFolders.map((folder) => folder.id),
+ ]);
+ const desiredItems = [...itemFolderIds].flatMap((folderId) =>
+ (projection.after.folders[folderId]?.serverIds ?? []).map((serverId, position) => ({
+ folderId,
+ serverId,
+ position,
+ })),
+ );
+ const reassignedServerIds = [...new Set([
+ ...projection.movedServerIds,
+ ...desiredItems.map((item) => item.serverId),
+ ])];
+ if (projection.createdFolders.length > 0) {
+ statements.push(createFolderStatement(db, userId, projection.createdFolders[0]!));
+ }
+ if (reassignedServerIds.length > 0) {
+ statements.push(globalReassignedItemCleanupStatement(db, userId, reassignedServerIds));
+ }
+ if (projection.affectedFolderIds.length > 0) {
+ statements.push(clearAffectedFolderItemsStatement(db, userId, projection.affectedFolderIds));
+ }
+ if (projection.deletedFolderIds.length > 0) {
+ statements.push(deleteFoldersStatement(db, userId, projection.deletedFolderIds));
+ }
+
+ if (desiredItems.length > 0) {
+ statements.push(insertFolderItemsStatement(db, userId, desiredItems));
+ }
+ if (projection.reorderServers) {
+ statements.push(membershipReorderStatement(db, userId, projection.after.serverOrder));
+ }
+ if (projection.reorderFolders) {
+ statements.push(folderReorderStatement(db, userId, projection.after.folderOrder));
+ }
+ statements.push(deleteEmptyFoldersStatement(db, userId));
+ statements.push(normalizeFolderPositionsStatement(db, userId));
+ statements.push(normalizeFolderItemPositionsStatement(db, userId));
+ if (statements.length === 0 || statements.length > SERVER_RAIL_MAX_WRITE_STATEMENTS) {
+ throw new Error(`invalid server rail write statement count: ${statements.length}`);
+ }
+ return statements as [any, ...any[]];
+}
+
+export async function applyServerRailProjection(
+ db: Database,
+ userId: string,
+ projection: ServerRailProjection,
+): Promise<void> {
+ const statements = buildServerRailWriteStatements(db, userId, projection);
+ await db.batch(statements as any);
+}
diff --git a/src/shared/src/index.ts b/src/shared/src/index.ts
index 3a0e5266d..61cb8ba10 100644
--- a/src/shared/src/index.ts
+++ b/src/shared/src/index.ts
@@ -649,6 +649,25 @@ export { createDb } from "./db/index";
export type { Database } from "./db/index";
export { withD1Retry, readOrStale, isRetryableD1Error } from "./db/resilience";
export type { RetryOpts } from "./db/resilience";
+export {
+ MAX_SERVER_RAIL_COMMANDS,
+ MAX_SERVER_RAIL_FOLDERS,
+ MAX_SERVER_RAIL_REQUEST_BYTES,
+ SERVER_RAIL_SNAPSHOT_STATEMENTS,
+ SERVER_RAIL_MAX_WRITE_STATEMENTS,
+ serverRailCommandSchema,
+ serverRailCommitRequestSchema,
+ projectServerRailCommit,
+} from "./community-server-rail";
+export type {
+ ServerRailCommand,
+ ServerRailCommitRequest,
+ ServerRailCommitResponse,
+ ServerRailFolderState,
+ ServerRailState,
+ ServerRailProjection,
+ ServerRailProjectionResult,
+} from "./community-server-rail";
export * as schema from "./db/schema";
export * as queries from "./db/queries-index";
export { communityServer, communityServerInvite, communityFriendship, communityServerMember, communityServerFolder, communityServerFolderItem, communityBotActivityEvent, communityBotDailyActivity } from "./db/community-schema";
diff --git a/src/shared/test/queries/community-member-rail-cleanup.test.ts b/src/shared/test/queries/community-member-rail-cleanup.test.ts
new file mode 100644
index 000000000..f21ecf699
--- /dev/null
+++ b/src/shared/test/queries/community-member-rail-cleanup.test.ts
@@ -0,0 +1,100 @@
+import Sqlite from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { describe, expect, it } from "vitest";
+import { projectServerRailCommit } from "../../src/community-server-rail";
+import { removeMemberAndOwnerBots } from "../../src/db/queries/community/member";
+import {
+ buildServerRailWriteStatements,
+ readServerRailSnapshot,
+} from "../../src/db/queries/community/server-rail";
+
+function createDatabase() {
+ const sqlite = new Sqlite(":memory:");
+ sqlite.exec(`
+ PRAGMA foreign_keys = ON;
+ CREATE TABLE community_server (id TEXT PRIMARY KEY);
+ CREATE TABLE community_server_member (
+ id TEXT PRIMARY KEY,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ user_id TEXT NOT NULL,
+ role TEXT DEFAULT 'member',
+ rail_order INTEGER DEFAULT 0,
+ joined_at TEXT NOT NULL
+ );
+ CREATE TABLE community_server_folder (
+ id TEXT PRIMARY KEY,
+ user_id TEXT NOT NULL,
+ name TEXT NOT NULL,
+ position INTEGER DEFAULT 0
+ );
+ CREATE TABLE community_server_folder_item (
+ folder_id TEXT NOT NULL REFERENCES community_server_folder(id) ON DELETE CASCADE,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ position INTEGER DEFAULT 0,
+ PRIMARY KEY(folder_id, server_id)
+ );
+ `);
+ const db = drizzle(sqlite) as any;
+ db.batch = async (statements: any[]) => sqlite.transaction(() =>
+ statements.map((statement, index) => index === 2 ? statement.all() : statement.run()),
+ )();
+ return { sqlite, db };
+}
+
+describe("member removal server rail cleanup", () => {
+ it("removes unique-item folders for the target and owner bots before the next rail mutation", async () => {
+ const { sqlite, db } = createDatabase();
+ sqlite.exec(`
+ INSERT INTO community_server (id) VALUES ('gone'), ('keep');
+ INSERT INTO community_server_member (id, server_id, user_id, role, rail_order, joined_at)
+ VALUES
+ ('target-gone', 'gone', 'target', 'member', 0, '2026-01-01T00:00:00.000Z'),
+ ('target-keep', 'keep', 'target', 'member', 1, '2026-01-01T00:00:01.000Z'),
+ ('bot-gone', 'gone', 'bot', 'member', 0, '2026-01-01T00:00:00.000Z'),
+ ('other-gone', 'gone', 'other', 'member', 0, '2026-01-01T00:00:00.000Z');
+ INSERT INTO community_server_folder (id, user_id, name, position)
+ VALUES
+ ('target-folder', 'target', 'Target', 0),
+ ('bot-folder', 'bot', 'Bot', 0),
+ ('other-folder', 'other', 'Other', 0);
+ INSERT INTO community_server_folder_item (folder_id, server_id, position)
+ VALUES
+ ('target-folder', 'gone', 0),
+ ('bot-folder', 'gone', 0),
+ ('other-folder', 'gone', 0);
+ `);
+
+ await expect(removeMemberAndOwnerBots(
+ db,
+ "target-gone",
+ "gone",
+ "target",
+ ["bot"],
+ )).resolves.toMatchObject({ id: "target-gone" });
+
+ expect(sqlite.prepare(`
+ SELECT id FROM community_server_folder ORDER BY id
+ `).all()).toEqual([{ id: "other-folder" }]);
+ expect(sqlite.prepare(`
+ SELECT folder_id AS folderId, server_id AS serverId
+ FROM community_server_folder_item
+ `).all()).toEqual([{ folderId: "other-folder", serverId: "gone" }]);
+
+ db.batch = async (statements: any[]) => statements.map((statement) => statement.all());
+ const snapshot = await readServerRailSnapshot(db, "target");
+ expect(snapshot).toEqual({ serverOrder: ["keep"], folderOrder: [], folders: {} });
+ const next = projectServerRailCommit(snapshot, {
+ commands: [{
+ kind: "create-folder",
+ clientId: "next",
+ name: "Next",
+ serverIds: ["keep"],
+ }],
+ }, () => "next-folder");
+ expect(next.ok).toBe(true);
+ if (!next.ok) throw new Error(next.error);
+ const statements = buildServerRailWriteStatements(db, "target", next.value);
+ expect(() => sqlite.transaction(() => statements.forEach((statement) => statement.run()))())
+ .not.toThrow();
+ });
+});
diff --git a/src/shared/test/queries/community-member.test.ts b/src/shared/test/queries/community-member.test.ts
index f180a8785..3633d17a5 100644
--- a/src/shared/test/queries/community-member.test.ts
+++ b/src/shared/test/queries/community-member.test.ts
@@ -44,7 +44,11 @@ describe("community/member exports", () => {
});
describe("removeMemberAndOwnerBots", () => {
- it("batches the target and bot deletes and returns the removed target", async () => {
+ it("batches rail cleanup with target and bot deletes and returns the removed target", async () => {
+ const cleanupStatement: any = {};
+ cleanupStatement.where = vi.fn(() => cleanupStatement);
+ const emptyFolderStatement: any = {};
+ emptyFolderStatement.where = vi.fn(() => emptyFolderStatement);
const targetStatement: any = {};
targetStatement.where = vi.fn(() => targetStatement);
targetStatement.returning = vi.fn(() => targetStatement);
@@ -53,19 +57,32 @@ describe("removeMemberAndOwnerBots", () => {
const db: any = {
delete: vi
.fn()
+ .mockReturnValueOnce(cleanupStatement)
+ .mockReturnValueOnce(emptyFolderStatement)
.mockReturnValueOnce(targetStatement)
.mockReturnValueOnce(botsStatement),
- batch: vi.fn().mockResolvedValue([[{ id: "mem_1" }], { rowsAffected: 2 }]),
+ batch: vi.fn().mockResolvedValue([
+ { rowsAffected: 3 },
+ { rowsAffected: 2 },
+ [{ id: "mem_1" }],
+ { rowsAffected: 2 },
+ ]),
};
await expect(memberQueries.removeMemberAndOwnerBots(
db,
"mem_1",
"srv_1",
+ "user_1",
["bot_1", "bot_2"],
)).resolves.toEqual({ id: "mem_1" });
- expect(db.batch).toHaveBeenCalledWith([targetStatement, botsStatement]);
+ expect(db.batch).toHaveBeenCalledWith([
+ cleanupStatement,
+ emptyFolderStatement,
+ targetStatement,
+ botsStatement,
+ ]);
});
});
diff --git a/src/shared/test/queries/community-server-rail.test.ts b/src/shared/test/queries/community-server-rail.test.ts
new file mode 100644
index 000000000..aed24b4e5
--- /dev/null
+++ b/src/shared/test/queries/community-server-rail.test.ts
@@ -0,0 +1,418 @@
+import Sqlite from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { describe, expect, it } from "vitest";
+import {
+ projectServerRailCommit,
+ type ServerRailCommitRequest,
+ type ServerRailState,
+} from "../../src/community-server-rail";
+import {
+ buildServerRailWriteStatements,
+ readServerRailSnapshot,
+} from "../../src/db/queries/community/server-rail";
+
+function createDatabase() {
+ const sqlite = new Sqlite(":memory:");
+ sqlite.exec(`
+ PRAGMA foreign_keys = ON;
+ CREATE TABLE community_server (
+ id TEXT PRIMARY KEY
+ );
+ CREATE TABLE community_server_member (
+ id TEXT PRIMARY KEY,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ user_id TEXT NOT NULL,
+ role TEXT DEFAULT 'member',
+ rail_order INTEGER DEFAULT 0,
+ joined_at TEXT NOT NULL
+ );
+ CREATE UNIQUE INDEX uq_server_member_server_user
+ ON community_server_member(server_id, user_id);
+ CREATE TABLE community_server_folder (
+ id TEXT PRIMARY KEY,
+ user_id TEXT NOT NULL,
+ name TEXT NOT NULL,
+ position INTEGER DEFAULT 0
+ );
+ CREATE TABLE community_server_folder_item (
+ folder_id TEXT NOT NULL REFERENCES community_server_folder(id) ON DELETE CASCADE,
+ server_id TEXT NOT NULL REFERENCES community_server(id) ON DELETE CASCADE,
+ position INTEGER DEFAULT 0,
+ PRIMARY KEY(folder_id, server_id)
+ );
+ `);
+ return { sqlite, db: drizzle(sqlite) };
+}
+
+function runProjection(
+ sqlite: Sqlite.Database,
+ db: ReturnType<typeof drizzle>,
+ state: ServerRailState,
+ request: ServerRailCommitRequest,
+ createId = () => "created",
+) {
+ const result = projectServerRailCommit(state, request, createId);
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error(result.error);
+ const statements = buildServerRailWriteStatements(db as any, "u1", result.value);
+ sqlite.transaction(() => {
+ for (const statement of statements) statement.run();
+ })();
+ return { projection: result.value, statements };
+}
+
+function seedMemberships(sqlite: Sqlite.Database, ids: string[]) {
+ const server = sqlite.prepare("INSERT INTO community_server (id) VALUES (?)");
+ const member = sqlite.prepare(`
+ INSERT INTO community_server_member (id, server_id, user_id, rail_order, joined_at)
+ VALUES (?, ?, 'u1', ?, ?)
+ `);
+ ids.forEach((id, index) => {
+ server.run(id);
+ member.run(`member-${id}`, id, index, `2026-01-01T00:00:${String(index).padStart(2, "0")}.000Z`);
+ });
+}
+
+describe("community server rail D1 statements", () => {
+ it("reads memberships, folders, and items in one consistent three-statement batch", async () => {
+ const statementRows = [
+ [{ serverId: "s1" }, { serverId: "s2" }],
+ [{ id: "f1", name: "One" }],
+ [{ folderId: "f1", serverId: "s2" }],
+ ];
+ const db: any = {
+ select: () => {
+ const chain: any = {};
+ for (const name of ["from", "innerJoin", "where", "orderBy"]) {
+ chain[name] = () => chain;
+ }
+ return chain;
+ },
+ batch: async (statements: unknown[]) => {
+ expect(statements).toHaveLength(3);
+ return statementRows;
+ },
+ };
+ await expect(readServerRailSnapshot(db, "u1")).resolves.toEqual({
+ serverOrder: ["s1", "s2"],
+ folderOrder: ["f1"],
+ folders: { f1: { id: "f1", name: "One", serverIds: ["s2"] } },
+ });
+ });
+
+ it("reorders 125 memberships with one JSON expansion and fixed bind count", () => {
+ const { sqlite, db } = createDatabase();
+ const ids = Array.from({ length: 125 }, (_, index) => `s${index}`);
+ seedMemberships(sqlite, ids);
+ const state: ServerRailState = { serverOrder: ids, folderOrder: [], folders: {} };
+ const { statements } = runProjection(sqlite, db, state, {
+ commands: [{ kind: "reorder-servers", serverIds: [...ids].reverse() }],
+ });
+ expect(statements.length).toBeLessThanOrEqual(13);
+ const reorder = statements.find((statement) => statement.toSQL().sql.includes(
+ 'update "community_server_member"',
+ ));
+ expect(reorder).toBeDefined();
+ const query = reorder!.toSQL();
+ expect(query.sql).toContain("json_each");
+ expect(query.params).toHaveLength(2);
+ expect(query.params.every((param: unknown) => typeof param === "string")).toBe(true);
+ const order = sqlite.prepare(`
+ SELECT server_id AS id FROM community_server_member
+ WHERE user_id = 'u1' ORDER BY rail_order, server_id
+ `).all().map((row: any) => row.id);
+ expect(order).toEqual([...ids].reverse());
+ });
+
+ it("inserts 125 guarded folder items from one JSON statement", () => {
+ const { sqlite, db } = createDatabase();
+ const ids = Array.from({ length: 125 }, (_, index) => `s${index}`);
+ seedMemberships(sqlite, ids);
+ const state: ServerRailState = { serverOrder: ids, folderOrder: [], folders: {} };
+ const { statements } = runProjection(sqlite, db, state, {
+ commands: [{ kind: "create-folder", clientId: "tmp", name: "Group", serverIds: ids }],
+ });
+ expect(statements.length).toBeLessThanOrEqual(13);
+ const itemInsert = statements.find((statement) => {
+ const query = statement.toSQL();
+ return query.sql.includes("insert into \"community_server_folder_item\"");
+ });
+ expect(itemInsert).toBeDefined();
+ const itemQuery = itemInsert!.toSQL();
+ expect(itemQuery.sql).toContain("json_each");
+ expect(itemQuery.params.length).toBeLessThanOrEqual(100);
+ expect(sqlite.prepare(`
+ SELECT COUNT(*) AS count FROM community_server_folder_item WHERE folder_id = 'created'
+ `).get()).toEqual({ count: 125 });
+ const positions = sqlite.prepare(`
+ SELECT position FROM community_server_folder_item
+ WHERE folder_id = 'created' ORDER BY position
+ `).all().map((row: any) => row.position);
+ expect(positions).toEqual(Array.from({ length: 125 }, (_, index) => index));
+ });
+
+ it("rolls back the whole write when membership disappears before guarded insert", () => {
+ const { sqlite, db } = createDatabase();
+ seedMemberships(sqlite, ["a", "b"]);
+ const state: ServerRailState = { serverOrder: ["a", "b"], folderOrder: [], folders: {} };
+ const result = projectServerRailCommit(state, {
+ commands: [{ kind: "create-folder", clientId: "tmp", name: "Group", serverIds: ["a", "b"] }],
+ }, () => "created");
+ expect(result.ok).toBe(true);
+ if (!result.ok) return;
+ const statements = buildServerRailWriteStatements(db as any, "u1", result.value);
+ sqlite.prepare("DELETE FROM community_server_member WHERE user_id = 'u1' AND server_id = 'b'").run();
+ expect(() => sqlite.transaction(() => {
+ for (const statement of statements) statement.run();
+ })()).toThrow();
+ expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_server_folder").get()).toEqual({ count: 0 });
+ expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_server_folder_item").get()).toEqual({ count: 0 });
+ });
+
+ it("projects around legacy invalid rows and atomically self-heals only the caller on the first legal write", async () => {
+ const { sqlite, db } = createDatabase();
+ sqlite.exec(`
+ INSERT INTO community_server (id) VALUES ('a'), ('b'), ('x');
+ INSERT INTO community_server_member (id, server_id, user_id, rail_order, joined_at)
+ VALUES
+ ('u1-a', 'a', 'u1', 0, '2026-01-01T00:00:00.000Z'),
+ ('u1-b', 'b', 'u1', 1, '2026-01-01T00:00:01.000Z'),
+ ('u2-x', 'x', 'u2', 0, '2026-01-01T00:00:00.000Z');
+ INSERT INTO community_server_folder (id, user_id, name, position)
+ VALUES
+ ('u1-empty', 'u1', 'Empty', 0),
+ ('u1-a-locale-first', 'u1', 'Locale first', NULL),
+ ('u1-Z-binary-first', 'u1', 'Binary first', 0),
+ ('u1-dangling', 'u1', 'Dangling', 6),
+ ('u2-empty', 'u2', 'Foreign empty', 0),
+ ('u2-first', 'u2', 'Foreign first', 1),
+ ('u2-second', 'u2', 'Foreign second', 2);
+ INSERT INTO community_server_folder_item (folder_id, server_id, position)
+ VALUES
+ ('u1-a-locale-first', 'a', 7),
+ ('u1-Z-binary-first', 'a', 0),
+ ('u1-dangling', 'x', 0),
+ ('u2-first', 'x', 3),
+ ('u2-second', 'x', 0);
+ `);
+ const d1Db = Object.assign(db as any, {
+ batch: async (statements: any[]) => statements.map((statement) => statement.all()),
+ });
+
+ const snapshot = await readServerRailSnapshot(d1Db, "u1");
+ expect(snapshot).toEqual({
+ serverOrder: ["a", "b"],
+ folderOrder: ["u1-Z-binary-first"],
+ folders: {
+ "u1-Z-binary-first": {
+ id: "u1-Z-binary-first",
+ name: "Binary first",
+ serverIds: ["a"],
+ },
+ },
+ });
+ const projection = projectServerRailCommit(snapshot, {
+ commands: [{ kind: "reorder-servers", serverIds: ["b", "a"] }],
+ }, () => "unused");
+ expect(projection.ok).toBe(true);
+ if (!projection.ok) throw new Error(projection.error);
+ const statements = buildServerRailWriteStatements(db as any, "u1", projection.value);
+ expect(() => sqlite.transaction(() => statements.forEach((statement) => statement.run()))())
+ .not.toThrow();
+
+ expect(sqlite.prepare(`
+ SELECT id, position FROM community_server_folder WHERE user_id = 'u1' ORDER BY id
+ `).all()).toEqual([{ id: "u1-Z-binary-first", position: 0 }]);
+ expect(sqlite.prepare(`
+ SELECT folder_id AS folderId, server_id AS serverId, position
+ FROM community_server_folder_item WHERE folder_id = 'u1-Z-binary-first'
+ `).all()).toEqual([{ folderId: "u1-Z-binary-first", serverId: "a", position: 0 }]);
+ expect(sqlite.prepare(`
+ SELECT id, position FROM community_server_folder WHERE user_id = 'u2' ORDER BY id
+ `).all()).toEqual([
+ { id: "u2-empty", position: 0 },
+ { id: "u2-first", position: 1 },
+ { id: "u2-second", position: 2 },
+ ]);
+ expect(sqlite.prepare(`
+ SELECT folder_id AS folderId, server_id AS serverId, position
+ FROM community_server_folder_item WHERE folder_id LIKE 'u2-%'
+ ORDER BY folder_id
+ `).all()).toEqual([
+ { folderId: "u2-first", serverId: "x", position: 3 },
+ { folderId: "u2-second", serverId: "x", position: 0 },
+ ]);
+ expect(sqlite.prepare("PRAGMA foreign_key_check").all()).toEqual([]);
+ });
+
+ it("recovers a legacy folder overflow through a count-reducing delete before normal mutations resume", async () => {
+ const { sqlite, db } = createDatabase();
+ const ids = Array.from({ length: 11 }, (_, index) => `s${index}`);
+ seedMemberships(sqlite, ids);
+ ids.forEach((serverId, index) => {
+ sqlite.prepare(`
+ INSERT INTO community_server_folder (id, user_id, name, position)
+ VALUES (?, 'u1', ?, ?)
+ `).run(`f${index}`, `Folder ${index}`, index);
+ sqlite.prepare(`
+ INSERT INTO community_server_folder_item (folder_id, server_id, position)
+ VALUES (?, ?, 0)
+ `).run(`f${index}`, serverId);
+ });
+ const d1Db = Object.assign(db as any, {
+ batch: async (statements: any[]) => statements.map((statement) => statement.all()),
+ });
+ const overflow = await readServerRailSnapshot(d1Db, "u1");
+ expect(overflow.folderOrder).toHaveLength(11);
+ expect(projectServerRailCommit(overflow, {
+ commands: [{ kind: "reorder-servers", serverIds: [...ids].reverse() }],
+ }, () => "unused")).toMatchObject({ ok: false });
+
+ const recovery = projectServerRailCommit(overflow, {
+ commands: [{ kind: "delete-folder", folderId: "f10" }],
+ }, () => "unused");
+ expect(recovery.ok).toBe(true);
+ if (!recovery.ok) throw new Error(recovery.error);
+ const recoveryStatements = buildServerRailWriteStatements(db as any, "u1", recovery.value);
+ sqlite.transaction(() => recoveryStatements.forEach((statement) => statement.run()))();
+ expect(sqlite.prepare(`
+ SELECT id, position FROM community_server_folder WHERE user_id = 'u1' ORDER BY position
+ `).all()).toEqual(Array.from({ length: 10 }, (_, index) => ({ id: `f${index}`, position: index })));
+
+ const recovered = await readServerRailSnapshot(d1Db, "u1");
+ const next = projectServerRailCommit(recovered, {
+ commands: [{ kind: "reorder-servers", serverIds: [...ids].reverse() }],
+ }, () => "unused");
+ expect(next.ok).toBe(true);
+ if (!next.ok) throw new Error(next.error);
+ const nextStatements = buildServerRailWriteStatements(db as any, "u1", next.value);
+ expect(() => sqlite.transaction(() => nextStatements.forEach((statement) => statement.run()))())
+ .not.toThrow();
+ });
+
+ it("lets a stale same-folder reorder win without leaving a duplicate in another folder", () => {
+ const { sqlite, db } = createDatabase();
+ seedMemberships(sqlite, ["a", "b", "c"]);
+ sqlite.exec(`
+ INSERT INTO community_server_folder (id, user_id, name, position)
+ VALUES ('one', 'u1', 'One', 0), ('two', 'u1', 'Two', 1);
+ INSERT INTO community_server_folder_item (folder_id, server_id, position)
+ VALUES ('one', 'a', 0), ('one', 'b', 1), ('two', 'c', 0);
+ `);
+ const stale: ServerRailState = {
+ serverOrder: ["a", "b", "c"],
+ folderOrder: ["one", "two"],
+ folders: {
+ one: { id: "one", name: "One", serverIds: ["a", "b"] },
+ two: { id: "two", name: "Two", serverIds: ["c"] },
+ },
+ };
+
+ runProjection(sqlite, db, stale, {
+ commands: [
+ { kind: "replace-folder-items", folderId: "one", serverIds: ["b"] },
+ { kind: "replace-folder-items", folderId: "two", serverIds: ["c", "a"] },
+ ],
+ });
+ runProjection(sqlite, db, stale, {
+ commands: [{ kind: "replace-folder-items", folderId: "one", serverIds: ["b", "a"] }],
+ });
+
+ const rows = sqlite.prepare(`
+ SELECT folder_id AS folderId, server_id AS serverId, position
+ FROM community_server_folder_item
+ ORDER BY folder_id, position
+ `).all();
+ expect(rows).toEqual([
+ { folderId: "one", serverId: "b", position: 0 },
+ { folderId: "one", serverId: "a", position: 1 },
+ { folderId: "two", serverId: "c", position: 0 },
+ ]);
+ expect(sqlite.prepare(`
+ SELECT COUNT(*) AS count FROM community_server_folder_item WHERE server_id = 'a'
+ `).get()).toEqual({ count: 1 });
+ });
+
+ it.each([
+ ["first then second", ["x", "y"]],
+ ["second then first", ["y", "x"]],
+ ] as const)("removes the folder emptied by a concurrent same-server create: %s", async (_name, order) => {
+ const { sqlite, db } = createDatabase();
+ seedMemberships(sqlite, ["a", "b"]);
+ const stale: ServerRailState = { serverOrder: ["a", "b"], folderOrder: [], folders: {} };
+ const projections = Object.fromEntries(["x", "y"].map((id) => {
+ const result = projectServerRailCommit(stale, {
+ commands: [{ kind: "create-folder", clientId: id, name: id, serverIds: ["a"] }],
+ }, () => id);
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error(result.error);
+ return [id, result.value];
+ }));
+
+ for (const id of order) {
+ const statements = buildServerRailWriteStatements(db as any, "u1", projections[id]!);
+ sqlite.transaction(() => statements.forEach((statement) => statement.run()))();
+ }
+
+ const d1Db = Object.assign(db as any, {
+ batch: async (statements: any[]) => statements.map((statement) => statement.all()),
+ });
+ const snapshot = await readServerRailSnapshot(d1Db, "u1");
+ expect(snapshot.folderOrder).toEqual([order[1]]);
+ expect(snapshot.folders[order[1]]?.serverIds).toEqual(["a"]);
+ expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_server_folder").get())
+ .toEqual({ count: 1 });
+
+ const next = projectServerRailCommit(snapshot, {
+ commands: [{ kind: "delete-folder", folderId: order[1] }],
+ }, () => "unused");
+ expect(next.ok).toBe(true);
+ });
+
+ it.each([
+ ["first then second", ["x", "y"]],
+ ["second then first", ["y", "x"]],
+ ] as const)("enforces the folder cap at write time for either completion order: %s", async (_name, order) => {
+ const { sqlite, db } = createDatabase();
+ const ids = [...Array.from({ length: 9 }, (_, index) => `s${index}`), "a", "b"];
+ seedMemberships(sqlite, ids);
+ for (let index = 0; index < 9; index += 1) {
+ sqlite.prepare(`
+ INSERT INTO community_server_folder (id, user_id, name, position) VALUES (?, 'u1', ?, ?)
+ `).run(`f${index}`, `Folder ${index}`, index);
+ sqlite.prepare(`
+ INSERT INTO community_server_folder_item (folder_id, server_id, position) VALUES (?, ?, 0)
+ `).run(`f${index}`, `s${index}`);
+ }
+ const d1Db = Object.assign(db as any, {
+ batch: async (statements: any[]) => statements.map((statement) => statement.all()),
+ });
+ const stale = await readServerRailSnapshot(d1Db, "u1");
+ const projections = Object.fromEntries(["x", "y"].map((id, index) => {
+ const result = projectServerRailCommit(stale, {
+ commands: [{ kind: "create-folder", clientId: id, name: id, serverIds: [index ? "b" : "a"] }],
+ }, () => id);
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error(result.error);
+ return [id, result.value];
+ }));
+
+ const firstStatements = buildServerRailWriteStatements(db as any, "u1", projections[order[0]]!);
+ sqlite.transaction(() => firstStatements.forEach((statement) => statement.run()))();
+ const secondStatements = buildServerRailWriteStatements(db as any, "u1", projections[order[1]]!);
+ expect(() => sqlite.transaction(() => secondStatements.forEach((statement) => statement.run()))())
+ .toThrow();
+ expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_server_folder").get())
+ .toEqual({ count: 10 });
+
+ const finalSnapshot = await readServerRailSnapshot(d1Db, "u1");
+ const next = projectServerRailCommit(finalSnapshot, {
+ commands: [{ kind: "reorder-servers", serverIds: [...finalSnapshot.serverOrder].reverse() }],
+ }, () => "unused");
+ expect(next.ok).toBe(true);
+ if (!next.ok) throw new Error(next.error);
+ const nextStatements = buildServerRailWriteStatements(db as any, "u1", next.value);
+ expect(() => sqlite.transaction(() => nextStatements.forEach((statement) => statement.run()))())
+ .not.toThrow();
+ });
+});
diff --git a/src/web/package.json b/src/web/package.json
index f80f407c9..367d3c026 100644
--- a/src/web/package.json
+++ b/src/web/package.json
@@ -27,6 +27,10 @@
},
"dependencies": {
"@alook/shared": "workspace:*",
+ "@atlaskit/pragmatic-drag-and-drop": "3.0.0",
+ "@atlaskit/pragmatic-drag-and-drop-auto-scroll": "3.1.0",
+ "@atlaskit/pragmatic-drag-and-drop-hitbox": "2.1.0",
+ "@atlaskit/pragmatic-drag-and-drop-live-region": "2.0.0",
"@base-ui/react": "^1.7.0",
"@dagrejs/dagre": "^3.1.1",
"@dnd-kit/core": "^6.3.1",
diff --git a/src/web/src/app/api/community/servers/[id]/leave/route.test.ts b/src/web/src/app/api/community/servers/[id]/leave/route.test.ts
index 6588497f8..c63bf968d 100644
--- a/src/web/src/app/api/community/servers/[id]/leave/route.test.ts
+++ b/src/web/src/app/api/community/servers/[id]/leave/route.test.ts
@@ -99,6 +99,7 @@ describe("POST /api/community/servers/[id]/leave", () => {
expect.anything(),
"mem_1",
"s1",
+ "u1",
["bot_1", "bot_2"],
)
expect(mockGetMember).toHaveBeenCalledTimes(1)
diff --git a/src/web/src/app/api/community/servers/[id]/leave/route.ts b/src/web/src/app/api/community/servers/[id]/leave/route.ts
index edc0ef8ba..4c3591951 100644
--- a/src/web/src/app/api/community/servers/[id]/leave/route.ts
+++ b/src/web/src/app/api/community/servers/[id]/leave/route.ts
@@ -33,6 +33,7 @@ export const POST = withAuth(async (_req, ctx) => {
db,
member.id,
serverId,
+ ctx.userId,
botIdsToCascade,
)
if (!removed) return writeError("member not found", 404)
diff --git a/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.test.ts b/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.test.ts
index 433efd4df..cbb0dbeb5 100644
--- a/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.test.ts
+++ b/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.test.ts
@@ -200,6 +200,7 @@ describe("DELETE /api/community/servers/[id]/members/[memberId]", () => {
expect.anything(),
"mem_target",
"srv_1",
+ "u_target",
[],
)
// Broadcast payload uses target.userId — proves the scoped helper's row
@@ -258,6 +259,7 @@ describe("DELETE /api/community/servers/[id]/members/[memberId]", () => {
expect.anything(),
"mem_target",
"srv_1",
+ "u_target",
["bot_1"],
)
expect(mockBroadcastToUserSafe).toHaveBeenCalledWith(
diff --git a/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.ts b/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.ts
index 504bd387b..38b425cac 100644
--- a/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.ts
+++ b/src/web/src/app/api/community/servers/[id]/members/[memberId]/route.ts
@@ -107,6 +107,7 @@ export const DELETE = withAuth(async (_req, ctx) => {
db,
memberId,
serverId,
+ target.userId,
botIdsToCascade,
)
if (!removed) return writeError("member not found", 404)
diff --git a/src/web/src/app/api/community/users/me/server-folders/[id]/route.test.ts b/src/web/src/app/api/community/users/me/server-folders/[id]/route.test.ts
new file mode 100644
index 000000000..94de7884d
--- /dev/null
+++ b/src/web/src/app/api/community/users/me/server-folders/[id]/route.test.ts
@@ -0,0 +1,87 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { NextRequest } from "next/server"
+
+const mocks = vi.hoisted(() => ({
+ getFolder: vi.fn(),
+ listMemberServerIds: vi.fn(),
+ readSnapshot: vi.fn(),
+ applyProjection: vi.fn(),
+}))
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+}))
+vi.mock("@/lib/db", () => ({ getDb: () => ({ id: "db" }) }))
+vi.mock("@alook/shared", async () => {
+ const actual = await vi.importActual<typeof import("@alook/shared")>("@alook/shared")
+ return {
+ ...actual,
+ queries: {
+ ...actual.queries,
+ communityMember: { listMemberServerIds: (...args: unknown[]) => mocks.listMemberServerIds(...args) },
+ communityServerFolder: {
+ getFolder: (...args: unknown[]) => mocks.getFolder(...args),
+ updateFolder: vi.fn(),
+ deleteFolder: vi.fn(),
+ },
+ communityServerRail: {
+ readServerRailSnapshot: (...args: unknown[]) => mocks.readSnapshot(...args),
+ applyServerRailProjection: (...args: unknown[]) => mocks.applyProjection(...args),
+ },
+ },
+ }
+})
+vi.mock("@/lib/middleware/auth", () => ({
+ withAuth: (handler: any) => (req: NextRequest) => handler(req, {
+ env: { DB: {} },
+ userId: "user_1",
+ params: { id: "folder_1" },
+ }),
+}))
+
+import { PATCH } from "./route"
+
+function request(serverIds: string[]) {
+ return new NextRequest("http://localhost/api/community/users/me/server-folders/folder_1", {
+ method: "PATCH",
+ body: JSON.stringify({ serverIds }),
+ })
+}
+
+describe("legacy server-folders PATCH rail invariants", () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mocks.getFolder.mockResolvedValue({ id: "folder_1", name: "Group", position: 0 })
+ mocks.listMemberServerIds.mockResolvedValue(["server_1", "server_2"])
+ mocks.readSnapshot.mockResolvedValue({
+ serverOrder: ["server_1", "server_2"],
+ folderOrder: ["folder_1"],
+ folders: {
+ folder_1: { id: "folder_1", name: "Group", serverIds: ["server_1"] },
+ },
+ })
+ mocks.applyProjection.mockResolvedValue(undefined)
+ })
+
+ it("rejects replacing a folder with an empty item list", async () => {
+ const response = await PATCH(request([]), {} as any)
+
+ expect(response.status).toBe(400)
+ expect(mocks.readSnapshot).not.toHaveBeenCalled()
+ expect(mocks.applyProjection).not.toHaveBeenCalled()
+ })
+
+ it("routes legacy item replacement through the rail projection batch", async () => {
+ const response = await PATCH(request(["server_2"]), {} as any)
+
+ expect(response.status).toBe(200)
+ expect(mocks.applyProjection).toHaveBeenCalledWith(
+ { id: "db" },
+ "user_1",
+ expect.objectContaining({
+ affectedFolderIds: ["folder_1"],
+ movedServerIds: ["server_1", "server_2"],
+ }),
+ )
+ })
+})
diff --git a/src/web/src/app/api/community/users/me/server-folders/[id]/route.ts b/src/web/src/app/api/community/users/me/server-folders/[id]/route.ts
index dfd03edb4..0124cb374 100644
--- a/src/web/src/app/api/community/users/me/server-folders/[id]/route.ts
+++ b/src/web/src/app/api/community/users/me/server-folders/[id]/route.ts
@@ -1,5 +1,5 @@
import { NextRequest } from "next/server"
-import { queries, MAX_FOLDER_NAME_LENGTH } from "@alook/shared"
+import { projectServerRailCommit, queries, MAX_FOLDER_NAME_LENGTH } from "@alook/shared"
import { getDb } from "@/lib/db"
import { withAuth } from "@/lib/middleware/auth"
import { writeJSON, writeError } from "@/lib/middleware/helpers"
@@ -31,19 +31,28 @@ export const PATCH = withAuth(async (req: NextRequest, ctx) => {
}
if (body.serverIds !== undefined) {
- if (!Array.isArray(body.serverIds)) {
- return writeError("serverIds must be an array", 400)
+ if (!Array.isArray(body.serverIds) || body.serverIds.length === 0) {
+ return writeError("serverIds must be a non-empty array", 400)
}
- if (body.serverIds.length > 0) {
- const memberServerIds = new Set(
- await queries.communityMember.listMemberServerIds(db, ctx.userId),
- )
- const stranger = body.serverIds.find((id) => !memberServerIds.has(id))
- if (stranger) {
- return writeError(`not a member of server ${stranger}`, 400)
- }
+ const memberServerIds = new Set(
+ await queries.communityMember.listMemberServerIds(db, ctx.userId),
+ )
+ const stranger = body.serverIds.find((id) => !memberServerIds.has(id))
+ if (stranger) {
+ return writeError(`not a member of server ${stranger}`, 400)
+ }
+ const snapshot = await queries.communityServerRail.readServerRailSnapshot(db, ctx.userId)
+ const currentIds = snapshot.folders[folderId]?.serverIds
+ if (!currentIds) return writeError("folder not found", 404)
+ const sameItems = currentIds.length === body.serverIds.length
+ && currentIds.every((id, index) => id === body.serverIds![index])
+ if (!sameItems) {
+ const projection = projectServerRailCommit(snapshot, {
+ commands: [{ kind: "replace-folder-items", folderId, serverIds: body.serverIds }],
+ }, () => "")
+ if (!projection.ok) return writeError(projection.error, projection.status)
+ await queries.communityServerRail.applyServerRailProjection(db, ctx.userId, projection.value)
}
- await queries.communityServerFolder.replaceFolderItems(db, folderId, body.serverIds)
}
const updated = await queries.communityServerFolder.getFolder(db, folderId, ctx.userId)
diff --git a/src/web/src/app/api/community/users/me/server-folders/route.test.ts b/src/web/src/app/api/community/users/me/server-folders/route.test.ts
new file mode 100644
index 000000000..1c2a88890
--- /dev/null
+++ b/src/web/src/app/api/community/users/me/server-folders/route.test.ts
@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { NextRequest } from "next/server"
+
+const mocks = vi.hoisted(() => ({
+ listMemberServerIds: vi.fn(),
+ readSnapshot: vi.fn(),
+ applyProjection: vi.fn(),
+ getFolder: vi.fn(),
+ nanoid: vi.fn(),
+}))
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+}))
+vi.mock("@/lib/db", () => ({ getDb: () => ({ id: "db" }) }))
+vi.mock("nanoid", async () => {
+ const actual = await vi.importActual<typeof import("nanoid")>("nanoid")
+ return { ...actual, nanoid: () => mocks.nanoid() }
+})
+vi.mock("@alook/shared", async () => {
+ const actual = await vi.importActual<typeof import("@alook/shared")>("@alook/shared")
+ return {
+ ...actual,
+ queries: {
+ ...actual.queries,
+ communityMember: { listMemberServerIds: (...args: unknown[]) => mocks.listMemberServerIds(...args) },
+ communityServerFolder: { getFolder: (...args: unknown[]) => mocks.getFolder(...args) },
+ communityServerRail: {
+ readServerRailSnapshot: (...args: unknown[]) => mocks.readSnapshot(...args),
+ applyServerRailProjection: (...args: unknown[]) => mocks.applyProjection(...args),
+ },
+ },
+ }
+})
+vi.mock("@/lib/middleware/auth", () => ({
+ withAuth: (handler: any) => (req: NextRequest) => handler(req, {
+ env: { DB: {} },
+ userId: "user_1",
+ }),
+}))
+
+import { POST } from "./route"
+
+function request(body: unknown) {
+ return new NextRequest("http://localhost/api/community/users/me/server-folders", {
+ method: "POST",
+ body: JSON.stringify(body),
+ })
+}
+
+describe("legacy server-folders POST rail invariants", () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mocks.nanoid.mockReturnValueOnce("client").mockReturnValueOnce("folder")
+ mocks.listMemberServerIds.mockResolvedValue(["server_1"])
+ mocks.readSnapshot.mockResolvedValue({
+ serverOrder: ["server_1"],
+ folderOrder: [],
+ folders: {},
+ })
+ mocks.applyProjection.mockResolvedValue(undefined)
+ mocks.getFolder.mockResolvedValue({ id: "folder", name: "Group", position: 0 })
+ })
+
+ it.each([undefined, []])("rejects an empty folder before reading or writing: %j", async (serverIds) => {
+ const response = await POST(request({ name: "Group", serverIds }), {} as any)
+
+ expect(response.status).toBe(400)
+ expect(mocks.readSnapshot).not.toHaveBeenCalled()
+ expect(mocks.applyProjection).not.toHaveBeenCalled()
+ })
+
+ it("routes legacy creates through the guarded rail projection batch", async () => {
+ const response = await POST(request({ name: "Group", serverIds: ["server_1"] }), {} as any)
+
+ expect(response.status).toBe(201)
+ expect(mocks.applyProjection).toHaveBeenCalledWith(
+ { id: "db" },
+ "user_1",
+ expect.objectContaining({
+ createdFolders: [{ id: "folder", name: "Group", serverIds: ["server_1"] }],
+ }),
+ )
+ })
+})
diff --git a/src/web/src/app/api/community/users/me/server-folders/route.ts b/src/web/src/app/api/community/users/me/server-folders/route.ts
index 7f046a2f0..191c7e311 100644
--- a/src/web/src/app/api/community/users/me/server-folders/route.ts
+++ b/src/web/src/app/api/community/users/me/server-folders/route.ts
@@ -1,5 +1,6 @@
import { NextRequest } from "next/server"
-import { queries, MAX_FOLDER_NAME_LENGTH } from "@alook/shared"
+import { nanoid } from "nanoid"
+import { projectServerRailCommit, queries, MAX_FOLDER_NAME_LENGTH } from "@alook/shared"
import { getDb } from "@/lib/db"
import { withAuth } from "@/lib/middleware/auth"
import { writeJSON, writeError } from "@/lib/middleware/helpers"
@@ -28,26 +29,31 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
return writeError(`name must be ≤ ${MAX_FOLDER_NAME_LENGTH} characters`, 400)
}
- if (body.serverIds !== undefined) {
- if (!Array.isArray(body.serverIds)) {
- return writeError("serverIds must be an array", 400)
- }
- if (body.serverIds.length > 0) {
- const memberServerIds = new Set(
- await queries.communityMember.listMemberServerIds(db, ctx.userId),
- )
- const stranger = body.serverIds.find((id) => !memberServerIds.has(id))
- if (stranger) {
- return writeError(`not a member of server ${stranger}`, 400)
- }
- }
+ if (!Array.isArray(body.serverIds) || body.serverIds.length === 0) {
+ return writeError("serverIds must be a non-empty array", 400)
+ }
+ const memberServerIds = new Set(
+ await queries.communityMember.listMemberServerIds(db, ctx.userId),
+ )
+ const stranger = body.serverIds.find((id) => !memberServerIds.has(id))
+ if (stranger) {
+ return writeError(`not a member of server ${stranger}`, 400)
}
- const folder = await queries.communityServerFolder.createFolder(db, {
- userId: ctx.userId,
- name,
- serverIds: body.serverIds,
- })
+ const snapshot = await queries.communityServerRail.readServerRailSnapshot(db, ctx.userId)
+ const clientId = `legacy_${nanoid()}`
+ const projection = projectServerRailCommit(snapshot, {
+ commands: [{ kind: "create-folder", clientId, name, serverIds: body.serverIds }],
+ }, () => nanoid())
+ if (!projection.ok) return writeError(projection.error, projection.status)
+ await queries.communityServerRail.applyServerRailProjection(db, ctx.userId, projection.value)
+ const folderId = projection.value.createdFolderIds[clientId]
+ const folder = folderId
+ ? await queries.communityServerFolder.getFolder(db, folderId, ctx.userId)
+ : null
+ if (!folder) {
+ return writeError("folder create conflicted with a newer rail update", 409)
+ }
return writeJSON(folder, 201)
})
diff --git a/src/web/src/app/api/community/users/me/server-rail/route.test.ts b/src/web/src/app/api/community/users/me/server-rail/route.test.ts
new file mode 100644
index 000000000..51146b43d
--- /dev/null
+++ b/src/web/src/app/api/community/users/me/server-rail/route.test.ts
@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { NextRequest } from "next/server"
+import { MAX_SERVER_RAIL_REQUEST_BYTES } from "@alook/shared"
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+}))
+
+const mockReadSnapshot = vi.fn()
+const mockApplyProjection = vi.fn()
+
+vi.mock("@/lib/db", () => ({ getDb: vi.fn(() => ({ id: "db" })) }))
+vi.mock("nanoid", async () => {
+ const actual = await vi.importActual<typeof import("nanoid")>("nanoid")
+ return { ...actual, nanoid: vi.fn(() => "folder_generated") }
+})
+vi.mock("@alook/shared", async () => {
+ const actual = await vi.importActual<typeof import("@alook/shared")>("@alook/shared")
+ return {
+ ...actual,
+ queries: {
+ ...actual.queries,
+ communityServerRail: {
+ readServerRailSnapshot: (...args: unknown[]) => mockReadSnapshot(...args),
+ applyServerRailProjection: (...args: unknown[]) => mockApplyProjection(...args),
+ },
+ },
+ }
+})
+vi.mock("@/lib/middleware/auth", () => ({
+ withAuth: vi.fn((handler: any) => async (req: any) => handler(req, {
+ env: { DB: {} },
+ userId: "user_1",
+ email: "[email protected]",
+ })),
+}))
+
+import { PATCH } from "./route"
+
+const snapshot = {
+ serverOrder: ["server_1", "server_2", "server_3"],
+ folderOrder: ["folder_1"],
+ folders: {
+ folder_1: { id: "folder_1", name: "Folder", serverIds: ["server_2"] },
+ },
+}
+
+function patchRequest(body: unknown) {
+ return new NextRequest("http://localhost/api/community/users/me/server-rail", {
+ method: "PATCH",
+ body: typeof body === "string" ? body : JSON.stringify(body),
+ })
+}
+
+describe("PATCH /api/community/users/me/server-rail", () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mockReadSnapshot.mockResolvedValue(snapshot)
+ mockApplyProjection.mockResolvedValue(undefined)
+ })
+
+ it("commits one validated projection and returns generated folder ids", async () => {
+ const response = await PATCH(patchRequest({
+ commands: [{
+ kind: "create-folder",
+ clientId: "temp_1",
+ name: "Pair",
+ serverIds: ["server_1", "server_3"],
+ }],
+ }), {} as any)
+
+ expect(response.status).toBe(200)
+ await expect(response.json()).resolves.toEqual({
+ createdFolderIds: { temp_1: "folder_generated" },
+ })
+ expect(mockReadSnapshot).toHaveBeenCalledWith({ id: "db" }, "user_1")
+ expect(mockApplyProjection).toHaveBeenCalledTimes(1)
+ expect(mockApplyProjection).toHaveBeenCalledWith(
+ { id: "db" },
+ "user_1",
+ expect.objectContaining({
+ createdFolderIds: { temp_1: "folder_generated" },
+ movedServerIds: ["server_1", "server_3"],
+ }),
+ )
+ })
+
+ it.each([
+ ["malformed JSON", "{"],
+ ["empty commands", { commands: [] }],
+ ["unknown fields", { commands: [{ kind: "reorder-servers", serverIds: snapshot.serverOrder, extra: true }] }],
+ ["partial memberships", { commands: [{ kind: "reorder-servers", serverIds: ["server_1"] }] }],
+ ["duplicate memberships", { commands: [{ kind: "reorder-servers", serverIds: ["server_1", "server_1", "server_3"] }] }],
+ ["foreign folder", { commands: [{ kind: "delete-folder", folderId: "folder_foreign" }] }],
+ ])("rejects %s without a write", async (_name, body) => {
+ const response = await PATCH(patchRequest(body), {} as any)
+
+ expect(response.status).toBeGreaterThanOrEqual(400)
+ expect(mockApplyProjection).not.toHaveBeenCalled()
+ })
+
+ it("rejects an oversized UTF-8 body before reading a snapshot", async () => {
+ const response = await PATCH(
+ patchRequest(`{"commands":[],"padding":"${"界".repeat(MAX_SERVER_RAIL_REQUEST_BYTES)}"}`),
+ {} as any,
+ )
+
+ expect(response.status).toBe(413)
+ expect(mockReadSnapshot).not.toHaveBeenCalled()
+ expect(mockApplyProjection).not.toHaveBeenCalled()
+ })
+
+ it("accepts a complete 125-membership reorder without cardinality rejection", async () => {
+ const serverOrder = Array.from({ length: 125 }, (_, index) => `server_${index}`)
+ mockReadSnapshot.mockResolvedValue({ serverOrder, folderOrder: [], folders: {} })
+
+ const response = await PATCH(patchRequest({
+ commands: [{ kind: "reorder-servers", serverIds: [...serverOrder].reverse() }],
+ }), {} as any)
+
+ expect(response.status).toBe(200)
+ expect(mockApplyProjection).toHaveBeenCalledTimes(1)
+ })
+
+ it("returns a 404 and executes zero writes for an unknown owned resource", async () => {
+ const response = await PATCH(patchRequest({
+ commands: [{ kind: "replace-folder-items", folderId: "missing", serverIds: ["server_1"] }],
+ }), {} as any)
+
+ expect(response.status).toBe(404)
+ expect(mockApplyProjection).not.toHaveBeenCalled()
+ })
+})
diff --git a/src/web/src/app/api/community/users/me/server-rail/route.ts b/src/web/src/app/api/community/users/me/server-rail/route.ts
new file mode 100644
index 000000000..6f55d5da2
--- /dev/null
+++ b/src/web/src/app/api/community/users/me/server-rail/route.ts
@@ -0,0 +1,40 @@
+import { nanoid } from "nanoid"
+import {
+ MAX_SERVER_RAIL_REQUEST_BYTES,
+ projectServerRailCommit,
+ queries,
+ serverRailCommitRequestSchema,
+} from "@alook/shared"
+import { getDb } from "@/lib/db"
+import { withAuth } from "@/lib/middleware/auth"
+import { writeError, writeJSON } from "@/lib/middleware/helpers"
+
+export const PATCH = withAuth(async (req, ctx) => {
+ const rawBody = await req.text()
+ if (new TextEncoder().encode(rawBody).byteLength > MAX_SERVER_RAIL_REQUEST_BYTES) {
+ return writeError("request body too large", 413)
+ }
+
+ let parsedBody: unknown
+ try {
+ parsedBody = JSON.parse(rawBody)
+ } catch {
+ return writeError("invalid request body", 400)
+ }
+
+ const request = serverRailCommitRequestSchema.safeParse(parsedBody)
+ if (!request.success) return writeError("invalid server rail commands", 400)
+
+ const db = getDb(ctx.env.DB)
+ const snapshot = await queries.communityServerRail.readServerRailSnapshot(db, ctx.userId)
+ const projection = projectServerRailCommit(snapshot, request.data, () => nanoid())
+ if (!projection.ok) return writeError(projection.error, projection.status)
+
+ await queries.communityServerRail.applyServerRailProjection(
+ db,
+ ctx.userId,
+ projection.value,
+ )
+
+ return writeJSON({ createdFolderIds: projection.value.createdFolderIds })
+})
diff --git a/src/web/src/components/community/shell/rail-folder.tsx b/src/web/src/components/community/shell/rail-folder.tsx
index c339e8071..69d8441ef 100644
--- a/src/web/src/components/community/shell/rail-folder.tsx
+++ b/src/web/src/components/community/shell/rail-folder.tsx
@@ -1,46 +1,66 @@
"use client"
-import { useSortable } from "@dnd-kit/sortable"
-import { CSS } from "@dnd-kit/utilities"
+import { useEffect, useRef } from "react"
import { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem } from "@/components/ui/context-menu"
import { RailIndicator } from "./rail-indicator"
import { Tooltip, TooltipTrigger, TooltipContent } from "@/components/ui/tooltip"
import { SeededBackdrop } from "@/components/avatar"
+import { tid } from "@/lib/community/testids"
import type { FolderServer } from "@/lib/community/models/navigation"
+import type { RailEntity, RailOperation } from "@/lib/community/server-rail-model"
export function RailFolder({
- sortableId, open, onToggle, activeId, folderServers, onUngroup, dragging: isDragActive,
+ folderId, open, onToggle, activeId, folderServers, onUngroup, dragging: isDragActive,
+ preview, registerItem, onMove,
}: {
folderId: string
- sortableId: string
open: boolean
onToggle: () => void
activeId: string
folderServers: FolderServer[]
onUngroup?: () => void
dragging?: boolean
+ preview?: RailOperation | null
+ registerItem?: (
+ entity: RailEntity,
+ element: HTMLElement,
+ dragHandle: HTMLElement,
+ ) => () => void
+ onMove?: (source: RailEntity, focusTarget: HTMLElement) => void
}) {
- const { attributes, listeners, setNodeRef, transform, transition, isDragging, isOver, activeIndex, index } = useSortable({ id: sortableId })
- const style = { transform: CSS.Transform.toString(transform), transition, opacity: isDragActive ? 0.3 : 1, zIndex: isDragging ? 10 : undefined }
- const showLine = isOver && !isDragging && !isDragActive
- const lineSide: "top" | "bottom" = activeIndex !== -1 && activeIndex < index ? "bottom" : "top"
+ const rootRef = useRef<HTMLDivElement>(null)
+ const buttonRef = useRef<HTMLButtonElement>(null)
+ useEffect(() => {
+ if (!registerItem || !rootRef.current || !buttonRef.current) return
+ return registerItem(
+ { kind: "folder", id: folderId },
+ rootRef.current,
+ buttonRef.current,
+ )
+ }, [folderId, registerItem])
return (
<Tooltip>
<TooltipTrigger render={<span className="flex w-full justify-center" />}>
<ContextMenu>
<ContextMenuTrigger
- render={<div ref={setNodeRef} style={style} className="group relative flex w-full justify-center" />}
+ render={<div ref={rootRef} style={{ opacity: isDragActive ? 0.3 : 1 }} className="group relative flex w-full justify-center" />}
>
- {showLine && <div className={`pointer-events-none absolute inset-x-3 z-10 h-0.5 rounded-full bg-primary ${lineSide === "top" ? "-top-1" : "-bottom-1"}`} />}
+ {(preview === "reorder-before" || preview === "reorder-after") && (
+ <div
+ data-testid={tid.serverRailInsertFolder(folderId)}
+ className={`pointer-events-none absolute left-1/2 z-10 h-0.5 w-9 -translate-x-1/2 rounded-full bg-primary ${preview === "reorder-before" ? "-top-1" : "-bottom-1"}`}
+ />
+ )}
<RailIndicator active={!open && folderServers.some((s) => s.id === activeId)} />
<button
+ ref={buttonRef}
+ data-testid={tid.serverRailFolder(folderId)}
onClick={onToggle}
- {...attributes}
- {...listeners}
className={[
- "grid size-10 cursor-pointer touch-none grid-cols-2 gap-1 p-2 transition-all duration-150 active:cursor-grabbing",
+ "grid size-10 cursor-pointer touch-manipulation grid-cols-2 gap-1 p-2 transition-[border-radius,background-color] duration-150 active:cursor-grabbing",
open ? "rounded-xl bg-primary/15" : "rounded-[18px] bg-accent hover:rounded-xl hover:bg-primary/20",
+ preview === "combine" ? "bg-primary/10 outline outline-2! outline-primary" : "",
].join(" ")}
>
{Array.from({ length: 4 }).map((_, i) => {
@@ -62,6 +82,13 @@ export function RailFolder({
</button>
</ContextMenuTrigger>
<ContextMenuContent className="w-52">
+ {onMove && (
+ <ContextMenuItem onClick={() => {
+ if (buttonRef.current) onMove({ kind: "folder", id: folderId }, buttonRef.current)
+ }}>
+ Move…
+ </ContextMenuItem>
+ )}
<ContextMenuItem onClick={onUngroup}>Ungroup</ContextMenuItem>
</ContextMenuContent>
</ContextMenu>
diff --git a/src/web/src/components/community/shell/server-rail-model.test.ts b/src/web/src/components/community/shell/server-rail-model.test.ts
new file mode 100644
index 000000000..559690776
--- /dev/null
+++ b/src/web/src/components/community/shell/server-rail-model.test.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it } from "vitest"
+import {
+ commitRailInstruction,
+ planRailPersistence,
+ railStateFromData,
+ railStateErrors,
+ visibleTopLevelServers,
+ type RailState,
+} from "@/lib/community/server-rail-model"
+
+function fixture(): RailState {
+ return {
+ serverOrder: ["a", "b", "c", "d", "e", "f"],
+ folderOrder: ["one", "two"],
+ folders: { one: ["c", "d"], two: ["e"] },
+ expanded: ["one"],
+ }
+}
+
+describe("server rail normalized reducer", () => {
+ it("projects legacy dangling, empty, and duplicate folders with the server snapshot ordering", () => {
+ const folder = (id: string, position: number, serverIds: string[]) => ({
+ id,
+ name: id,
+ position,
+ servers: serverIds.map((serverId) => ({ id: serverId, name: serverId, initial: serverId })),
+ })
+ expect(railStateFromData(["a", "b"], [
+ folder("empty", 0, []),
+ folder("a-locale-first", 1, ["a"]),
+ folder("Z-binary-first", 1, ["a"]),
+ folder("dangling", 2, ["foreign"]),
+ folder("valid", 3, ["b"]),
+ ], ["empty", "a-locale-first", "Z-binary-first", "valid"])).toEqual({
+ serverOrder: ["a", "b"],
+ folderOrder: ["Z-binary-first", "valid"],
+ folders: { "Z-binary-first": ["a"], valid: ["b"] },
+ expanded: ["Z-binary-first", "valid"],
+ })
+ })
+
+ it("keeps the full membership order while deriving top-level servers", () => {
+ expect(visibleTopLevelServers(fixture())).toEqual(["a", "b", "f"])
+ expect(railStateErrors(fixture())).toEqual([])
+ })
+
+ it("reorders top-level servers with one complete command", () => {
+ const result = commitRailInstruction(fixture(), {
+ operation: "reorder-after",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "b" },
+ })
+ expect(result).toMatchObject({ applied: true })
+ if (!result.applied) return
+ expect(result.state.serverOrder).toEqual(["b", "a", "c", "d", "e", "f"])
+ expect(result.commands).toEqual([
+ { kind: "reorder-servers", serverIds: ["b", "a", "c", "d", "e", "f"] },
+ ])
+ })
+
+ it("moves between folders with exactly two replace commands", () => {
+ const result = commitRailInstruction(fixture(), {
+ operation: "reorder-after",
+ source: { kind: "server", id: "c" },
+ target: { kind: "server", id: "e" },
+ })
+ expect(result).toMatchObject({ applied: true })
+ if (!result.applied) return
+ expect(result.state.folders).toEqual({ one: ["d"], two: ["e", "c"] })
+ expect(result.commands).toEqual([
+ { kind: "replace-folder-items", folderId: "one", serverIds: ["d"] },
+ { kind: "replace-folder-items", folderId: "two", serverIds: ["e", "c"] },
+ ])
+ })
+
+ it("deletes an emptied folder and preserves the complete membership order", () => {
+ const result = commitRailInstruction(fixture(), {
+ operation: "reorder-before",
+ source: { kind: "server", id: "e" },
+ target: { kind: "server", id: "f" },
+ })
+ expect(result).toMatchObject({ applied: true })
+ if (!result.applied) return
+ expect(result.state.folderOrder).toEqual(["one"])
+ expect(result.commands).toEqual([{ kind: "delete-folder", folderId: "two" }])
+ })
+
+ it("creates one temporary folder command from two top-level servers", () => {
+ const result = commitRailInstruction(fixture(), {
+ operation: "combine",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "b" },
+ newFolderId: "temp_one",
+ })
+ expect(result).toMatchObject({ applied: true })
+ if (!result.applied) return
+ expect(result.commands).toEqual([{
+ kind: "create-folder",
+ clientId: "temp_one",
+ name: "Group",
+ serverIds: ["a", "b"],
+ }])
+ })
+
+ it("plans folder reorder separately and treats no-op as zero-write", () => {
+ const before = fixture()
+ const after = { ...fixture(), folderOrder: ["two", "one"] }
+ expect(planRailPersistence(before, after)).toEqual([
+ { kind: "reorder-folders", folderIds: ["two", "one"] },
+ ])
+ expect(commitRailInstruction(before, {
+ operation: "reorder-before",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "a" },
+ })).toMatchObject({ applied: false })
+ })
+
+ it("rejects cross-kind reorder and duplicate-folder membership", () => {
+ expect(commitRailInstruction(fixture(), {
+ operation: "reorder-before",
+ source: { kind: "server", id: "a" },
+ target: { kind: "folder", id: "one" },
+ })).toMatchObject({ applied: false, reason: "server and folder orders cannot interleave" })
+ const invalid = fixture()
+ invalid.folders.two.push("c")
+ expect(railStateErrors(invalid)).toContain("server c belongs to multiple folders")
+ })
+})
diff --git a/src/web/src/components/community/shell/server-rail-move-menu.tsx b/src/web/src/components/community/shell/server-rail-move-menu.tsx
new file mode 100644
index 000000000..71717edd2
--- /dev/null
+++ b/src/web/src/components/community/shell/server-rail-move-menu.tsx
@@ -0,0 +1,192 @@
+"use client"
+
+import { useEffect, useMemo, useState } from "react"
+import { MAX_SERVER_RAIL_FOLDERS } from "@alook/shared"
+import { Button } from "@/components/ui/button"
+import { tid } from "@/lib/community/testids"
+import {
+ Sheet,
+ SheetBody,
+ SheetContent,
+ SheetDescription,
+ SheetFooter,
+ SheetHeader,
+ SheetTitle,
+} from "@/components/ui/sheet"
+import {
+ folderForServer,
+ visibleTopLevelServers,
+ type RailEntity,
+ type RailInstruction,
+ type RailState,
+} from "@/lib/community/server-rail-model"
+
+type Destination = "rail" | "new" | `folder:${string}` | "folders"
+
+export function ServerRailMoveMenu({
+ source,
+ state,
+ serverNames,
+ folderNames,
+ onClose,
+ onMove,
+}: {
+ source: RailEntity | null
+ state: RailState
+ serverNames: ReadonlyMap<string, string>
+ folderNames: ReadonlyMap<string, string>
+ onClose: () => void
+ onMove: (instruction: RailInstruction) => void
+}) {
+ const sourceFolder = source?.kind === "server" ? folderForServer(state, source.id) : null
+ const [destination, setDestination] = useState<Destination>("rail")
+ const [targetId, setTargetId] = useState("")
+ const [placement, setPlacement] = useState<"before" | "after" | "inside">("after")
+
+ const targets = useMemo(() => {
+ if (!source) return []
+ if (source.kind === "folder") {
+ return state.folderOrder.filter((folderId) => folderId !== source.id)
+ }
+ if (destination === "rail" || destination === "new") {
+ return visibleTopLevelServers(state).filter((serverId) => serverId !== source.id)
+ }
+ if (destination.startsWith("folder:")) {
+ return (state.folders[destination.slice("folder:".length)] ?? [])
+ .filter((serverId) => serverId !== source.id)
+ }
+ return []
+ }, [destination, source, state])
+
+ useEffect(() => {
+ if (!source) return
+ const initialDestination: Destination = source.kind === "folder"
+ ? "folders"
+ : sourceFolder
+ ? `folder:${sourceFolder}`
+ : "rail"
+ setDestination(initialDestination)
+ setPlacement("after")
+ }, [source, sourceFolder])
+
+ useEffect(() => {
+ setTargetId(targets[0] ?? "")
+ }, [targets])
+
+ const submit = () => {
+ if (!source || !targetId) return
+ const target: RailEntity = source.kind === "folder"
+ ? { kind: "folder", id: targetId }
+ : destination.startsWith("folder:") && placement === "inside"
+ ? { kind: "folder", id: destination.slice("folder:".length) }
+ : { kind: "server", id: targetId }
+ const operation = destination === "new" || placement === "inside"
+ ? "combine"
+ : placement === "before"
+ ? "reorder-before"
+ : "reorder-after"
+ onMove({
+ operation,
+ source,
+ target,
+ ...(destination === "new" ? { newFolderId: `temp_${crypto.randomUUID()}` } : {}),
+ })
+ }
+
+ return (
+ <Sheet open={!!source} onOpenChange={(open) => { if (!open) onClose() }}>
+ <SheetContent side="bottom" className="max-h-[min(32rem,80dvh)] rounded-t-2xl" showCloseButton>
+ <SheetHeader>
+ <SheetTitle>Move {source?.kind === "folder" ? "group" : "server"}</SheetTitle>
+ <SheetDescription>Choose a destination, then its exact position.</SheetDescription>
+ </SheetHeader>
+ <SheetBody className="space-y-4">
+ <label className="grid gap-1.5 text-sm font-medium">
+ <span>Destination</span>
+ <select
+ data-testid={tid.serverRailMoveDestination}
+ value={destination}
+ onChange={(event) => {
+ setDestination(event.target.value as Destination)
+ setPlacement("after")
+ }}
+ className="h-10 rounded-lg border border-input bg-card px-3 text-card-foreground outline-none focus:ring-2 focus:ring-ring"
+ >
+ {source?.kind === "folder" ? (
+ <option value="folders">Group order</option>
+ ) : (
+ <>
+ <option value="rail">Server rail</option>
+ {state.folderOrder.map((folderId) => (
+ <option key={folderId} value={`folder:${folderId}`}>
+ {folderNames.get(folderId) ?? "Group"}
+ </option>
+ ))}
+ {!sourceFolder && state.folderOrder.length < MAX_SERVER_RAIL_FOLDERS && (
+ <option value="new">New group</option>
+ )}
+ </>
+ )}
+ </select>
+ </label>
+ <label className="grid gap-1.5 text-sm font-medium">
+ <span>Position</span>
+ <select
+ data-testid={tid.serverRailMoveTarget}
+ value={targetId}
+ onChange={(event) => setTargetId(event.target.value)}
+ className="h-10 rounded-lg border border-input bg-card px-3 text-card-foreground outline-none focus:ring-2 focus:ring-ring"
+ >
+ {targets.map((id) => (
+ <option key={id} value={id}>
+ {source?.kind === "folder"
+ ? folderNames.get(id) ?? "Group"
+ : serverNames.get(id) ?? "Server"}
+ </option>
+ ))}
+ </select>
+ </label>
+ {destination !== "new" && targets.length > 0 && (
+ <div className="grid grid-cols-2 gap-2" role="group" aria-label="Placement">
+ <Button
+ type="button"
+ variant={placement === "before" ? "default" : "outline"}
+ onClick={() => setPlacement("before")}
+ >
+ Before
+ </Button>
+ <Button
+ type="button"
+ variant={placement === "after" ? "default" : "outline"}
+ onClick={() => setPlacement("after")}
+ >
+ After
+ </Button>
+ {source?.kind === "server" && destination.startsWith("folder:") && (
+ <Button
+ type="button"
+ variant={placement === "inside" ? "default" : "outline"}
+ className="col-span-2"
+ onClick={() => setPlacement("inside")}
+ >
+ Inside group
+ </Button>
+ )}
+ </div>
+ )}
+ </SheetBody>
+ <SheetFooter>
+ <Button type="button" variant="outline" onClick={onClose}>Cancel</Button>
+ <Button
+ type="button"
+ data-testid={tid.serverRailMoveConfirm}
+ disabled={!targetId}
+ onClick={submit}
+ >
+ Move
+ </Button>
+ </SheetFooter>
+ </SheetContent>
+ </Sheet>
+ )
+}
diff --git a/src/web/src/components/community/shell/server-rail-pdd-contract.test.ts b/src/web/src/components/community/shell/server-rail-pdd-contract.test.ts
new file mode 100644
index 000000000..40573f6a4
--- /dev/null
+++ b/src/web/src/components/community/shell/server-rail-pdd-contract.test.ts
@@ -0,0 +1,43 @@
+import { readFileSync } from "node:fs"
+import { describe, expect, it } from "vitest"
+
+const read = (name: string) => readFileSync(new URL(name, import.meta.url), "utf8")
+
+describe("server rail PDD component contract", () => {
+ it("uses Pragmatic Drag and Drop only in the server rail", () => {
+ const rail = read("./server-rail.tsx")
+ const adapter = read("./use-server-rail-pdd.ts")
+ const channelTree = read("../channels/use-channel-tree.ts")
+ expect(rail).toContain('from "./use-server-rail-pdd"')
+ expect(adapter).toContain("@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter")
+ expect(adapter).toContain("getIsSticky: () => false")
+ expect(rail).not.toContain("@dnd-kit")
+ expect(channelTree).toContain("@dnd-kit")
+ })
+
+ it("pins one inset indicator, one combine outline, and the 500ms expansion", () => {
+ const server = read("./sortable-server.tsx")
+ const folder = read("./rail-folder.tsx")
+ const adapter = read("./use-server-rail-pdd.ts")
+ for (const source of [server, folder]) {
+ expect(source).toContain("h-0.5 w-9")
+ expect(source).toContain("bg-primary/10 outline outline-2! outline-primary")
+ expect(source).not.toContain("ring-2 ring-primary")
+ }
+ expect(folder).toContain("transition-[border-radius,background-color]")
+ expect(server).toContain("transition-[border-radius,background-color,border-color,opacity,transform]")
+ expect(adapter).toContain("}, 500)")
+ })
+
+ it("keeps Move behind contextual actions and uses a compact two-step sheet", () => {
+ const server = read("./sortable-server.tsx")
+ const folder = read("./rail-folder.tsx")
+ const move = read("./server-rail-move-menu.tsx")
+ expect(server).toContain("Move…")
+ expect(folder).toContain("Move…")
+ expect(move).toContain("Choose a destination, then its exact position.")
+ expect(move).toContain('side="bottom"')
+ expect(move).toContain("tid.serverRailMoveDestination")
+ expect(move).not.toContain("fixed right-")
+ })
+})
diff --git a/src/web/src/components/community/shell/server-rail.pending.test.ts b/src/web/src/components/community/shell/server-rail.pending.test.ts
new file mode 100644
index 000000000..9106e922d
--- /dev/null
+++ b/src/web/src/components/community/shell/server-rail.pending.test.ts
@@ -0,0 +1,257 @@
+import { createElement, type ReactNode } from "react"
+import TestRenderer, { act } from "react-test-renderer"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { ServerRail } from "./server-rail"
+import { tid } from "@/lib/community/testids"
+import type { RailInstruction } from "@/lib/community/server-rail-model"
+
+const mocks = vi.hoisted(() => ({
+ mutate: vi.fn(),
+ announce: vi.fn(),
+ capturePddOptions: vi.fn(),
+ querySelector: vi.fn(),
+}))
+
+vi.mock("@atlaskit/pragmatic-drag-and-drop-live-region", () => ({
+ announce: mocks.announce,
+ cleanup: vi.fn(),
+}))
+vi.mock("@/hooks/community/mutations", () => ({
+ useServerRailCommit: () => ({ mutate: mocks.mutate, isPending: false }),
+}))
+vi.mock("./use-server-rail-pdd", () => ({
+ useServerRailPdd: (options: unknown) => {
+ mocks.capturePddOptions(options)
+ return { registerItem: vi.fn() }
+ },
+}))
+vi.mock("./sortable-server", () => ({
+ SortableServer: (props: Record<string, unknown>) => createElement("sortable-server", props),
+}))
+vi.mock("./rail-folder", () => ({
+ RailFolder: (props: Record<string, unknown>) => createElement("rail-folder", props),
+}))
+vi.mock("./rail-icon", () => ({ RailIcon: () => null }))
+vi.mock("./animated-alook-logo", () => ({ AnimatedAlookLogo: () => null }))
+vi.mock("./server-rail-move-menu", () => ({ ServerRailMoveMenu: () => null }))
+vi.mock("../settings/create-server-dialog", () => ({ CreateServerDialog: () => null }))
+vi.mock("@/components/ui/skeleton", () => ({ Skeleton: () => null }))
+vi.mock("@/components/ui/tooltip", () => ({
+ Tooltip: ({ children }: { children: ReactNode }) => children,
+ TooltipTrigger: ({ children }: { children: ReactNode }) => children,
+ TooltipContent: ({ children }: { children: ReactNode }) => children,
+}))
+vi.mock("@/lib/community-onboarding", () => ({
+ completeCommunityOnboarding: vi.fn(),
+ isCommunityOnboardingStage: () => false,
+}))
+
+const servers = [
+ { id: "a", name: "A", initial: "A", active: true, mentions: 0 },
+ { id: "b", name: "B", initial: "B", active: false, mentions: 0 },
+]
+const folders = [{
+ id: "one",
+ name: "One",
+ position: 0,
+ servers: [{ id: "b", name: "B", initial: "B" }],
+}]
+const animationFrames: FrameRequestCallback[] = []
+
+function renderRail() {
+ return TestRenderer.create(createElement(ServerRail, {
+ servers,
+ folders,
+ view: "server",
+ onHome: vi.fn(),
+ }))
+}
+
+type MutationCallbacks = {
+ onSuccess: (response: { createdFolderIds: Record<string, string> }) => void
+ onError: () => void
+ onSettled: (data?: unknown, error?: Error | null) => void
+}
+
+function latestMutation() {
+ const call = mocks.mutate.mock.calls.at(-1)!
+ return {
+ args: call[0] as { commands: Array<{ kind: string; clientId?: string }> },
+ callbacks: call[1] as MutationCallbacks,
+ }
+}
+
+function drop(instruction: RailInstruction) {
+ const options = mocks.capturePddOptions.mock.calls.at(-1)![0] as {
+ onDrop: (instruction: RailInstruction) => void
+ }
+ options.onDrop(instruction)
+}
+
+function flushAnimationFrame() {
+ const callback = animationFrames.shift()
+ if (!callback) throw new Error("Expected a queued animation frame")
+ callback(0)
+}
+
+async function expectReconciledFocus(testId: string, focus: ReturnType<typeof vi.fn>) {
+ expect(mocks.querySelector).not.toHaveBeenCalled()
+ expect(focus).not.toHaveBeenCalled()
+ await act(async () => flushAnimationFrame())
+ expect(mocks.querySelector).not.toHaveBeenCalled()
+ expect(focus).not.toHaveBeenCalled()
+ await act(async () => flushAnimationFrame())
+ expect(mocks.querySelector).toHaveBeenLastCalledWith(`[data-testid="${testId}"]`)
+ expect(focus).toHaveBeenCalledTimes(1)
+}
+
+describe("ServerRail one-in-flight structural guard", () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ animationFrames.length = 0
+ vi.stubGlobal("sessionStorage", { getItem: vi.fn(() => null), setItem: vi.fn() })
+ vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true)
+ vi.stubGlobal("document", { querySelector: mocks.querySelector })
+ vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {
+ animationFrames.push(callback)
+ return animationFrames.length
+ })
+ })
+ afterEach(() => vi.unstubAllGlobals())
+
+ it.each(["create-first", "ungroup-first"] as const)(
+ "allows one PATCH when stale create and ungroup callbacks race: %s",
+ async (order) => {
+ let renderer!: TestRenderer.ReactTestRenderer
+ await act(async () => { renderer = renderRail() })
+ const create = renderer.root.findAllByType("sortable-server")[0]!.props.onCreateFolder
+ const ungroup = renderer.root.findByType("rail-folder").props.onUngroup
+
+ await act(async () => {
+ if (order === "create-first") {
+ create()
+ ungroup()
+ } else {
+ ungroup()
+ create()
+ }
+ })
+
+ expect(mocks.mutate).toHaveBeenCalledTimes(1)
+ expect(mocks.announce).toHaveBeenCalledWith("A server rail move is already being saved")
+
+ const options = mocks.mutate.mock.calls[0]![1]
+ await act(async () => { options.onSettled() })
+ await act(async () => {
+ if (order === "create-first") ungroup()
+ else create()
+ })
+ expect(mocks.mutate).toHaveBeenCalledTimes(2)
+ },
+ )
+
+ it("keeps immediate rejected-operation focus on one animation frame", async () => {
+ const focus = vi.fn()
+ mocks.querySelector.mockReturnValue({ focus })
+ await act(async () => { renderRail() })
+ await act(async () => drop({
+ operation: "reorder-after",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "a" },
+ }))
+
+ expect(mocks.mutate).not.toHaveBeenCalled()
+ expect(focus).not.toHaveBeenCalled()
+ await act(async () => flushAnimationFrame())
+ expect(mocks.querySelector).toHaveBeenLastCalledWith(
+ `[data-testid="${tid.serverIcon("a")}"]`,
+ )
+ expect(focus).toHaveBeenCalledTimes(1)
+ expect(animationFrames).toHaveLength(0)
+ })
+
+ it.each(["success", "error"] as const)(
+ "returns Move focus only after the mutation settles: %s",
+ async (outcome) => {
+ const focus = vi.fn()
+ mocks.querySelector.mockReturnValue({ focus })
+ await act(async () => { renderRail() })
+ await act(async () => drop({
+ operation: "reorder-after",
+ source: { kind: "server", id: "a" },
+ target: { kind: "server", id: "b" },
+ }))
+ const { callbacks } = latestMutation()
+
+ await act(async () => {
+ if (outcome === "success") callbacks.onSuccess({ createdFolderIds: {} })
+ else callbacks.onError()
+ })
+ expect(focus).not.toHaveBeenCalled()
+
+ await act(async () => callbacks.onSettled(
+ undefined,
+ outcome === "error" ? new Error("failed") : null,
+ ))
+ await expectReconciledFocus(tid.serverIcon("a"), focus)
+ },
+ )
+
+ it.each(["success", "error"] as const)(
+ "returns Create group focus to its source server after settle: %s",
+ async (outcome) => {
+ const focus = vi.fn()
+ mocks.querySelector.mockReturnValue({ focus })
+ let renderer!: TestRenderer.ReactTestRenderer
+ await act(async () => { renderer = renderRail() })
+ const create = renderer.root.findAllByType("sortable-server")
+ .find((node) => node.props.server.id === "a")!.props.onCreateFolder
+ await act(async () => create())
+ const { args, callbacks } = latestMutation()
+
+ await act(async () => {
+ if (outcome === "success") {
+ const clientId = args.commands[0]?.clientId
+ callbacks.onSuccess({ createdFolderIds: clientId ? { [clientId]: "created" } : {} })
+ } else {
+ callbacks.onError()
+ }
+ })
+ expect(focus).not.toHaveBeenCalled()
+
+ await act(async () => callbacks.onSettled(
+ undefined,
+ outcome === "error" ? new Error("failed") : null,
+ ))
+ await expectReconciledFocus(tid.serverIcon("a"), focus)
+ },
+ )
+
+ it.each(["success", "error"] as const)(
+ "returns Ungroup focus after settle to a surviving entity: %s",
+ async (outcome) => {
+ const focus = vi.fn()
+ mocks.querySelector.mockReturnValue({ focus })
+ let renderer!: TestRenderer.ReactTestRenderer
+ await act(async () => { renderer = renderRail() })
+ const ungroup = renderer.root.findByType("rail-folder").props.onUngroup
+ await act(async () => ungroup())
+ const { callbacks } = latestMutation()
+
+ await act(async () => {
+ if (outcome === "success") callbacks.onSuccess({ createdFolderIds: {} })
+ else callbacks.onError()
+ })
+ expect(focus).not.toHaveBeenCalled()
+
+ await act(async () => callbacks.onSettled(
+ undefined,
+ outcome === "error" ? new Error("failed") : null,
+ ))
+ await expectReconciledFocus(
+ outcome === "success" ? tid.serverIcon("b") : tid.serverRailFolder("one"),
+ focus,
+ )
+ },
+ )
+})
diff --git a/src/web/src/components/community/shell/server-rail.tsx b/src/web/src/components/community/shell/server-rail.tsx
index f851b3051..10d97e8e5 100644
--- a/src/web/src/components/community/shell/server-rail.tsx
+++ b/src/web/src/components/community/shell/server-rail.tsx
@@ -1,12 +1,9 @@
"use client"
-import { memo, useEffect, useMemo, useState, type ReactNode } from "react"
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react"
import { Plus } from "lucide-react"
-import {
- DndContext, closestCenter, PointerSensor, useSensor, useSensors, DragOverlay,
-} from "@dnd-kit/core"
-import { SortableContext, verticalListSortingStrategy } from "@dnd-kit/sortable"
-import { restrictToVerticalAxis } from "@dnd-kit/modifiers"
+import { MAX_SERVER_RAIL_FOLDERS } from "@alook/shared"
+import { announce, cleanup as cleanupLiveRegion } from "@atlaskit/pragmatic-drag-and-drop-live-region"
import { RailIcon } from "./rail-icon"
import { AnimatedAlookLogo } from "./animated-alook-logo"
import { tid } from "@/lib/community/testids"
@@ -15,19 +12,64 @@ import { Skeleton } from "@/components/ui/skeleton"
import { SortableServer } from "./sortable-server"
import { RailFolder } from "./rail-folder"
import { CreateServerDialog } from "../settings/create-server-dialog"
-import { useRailOrder, isFolderKey, extractFolderId } from "./use-rail-order"
-import { SeededBackdrop } from "@/components/avatar"
-import type { Server, CommunityFolder } from "@/lib/community/models/navigation"
+import { ServerRailMoveMenu } from "./server-rail-move-menu"
+import {
+ cloneRailState,
+ commitRailInstruction,
+ planRailPersistence,
+ railMoveAnnouncement,
+ railStateFromData,
+ visibleTopLevelServers,
+ type RailEntity,
+ type RailInstruction,
+ type RailState,
+} from "@/lib/community/server-rail-model"
+import { useServerRailPdd } from "./use-server-rail-pdd"
+import { useServerRailCommit } from "@/hooks/community/mutations"
+import type { Server, CommunityFolder, FolderServer } from "@/lib/community/models/navigation"
import type { View } from "@/components/community/shell/shell-types"
import {
completeCommunityOnboarding,
isCommunityOnboardingStage,
} from "@/lib/community-onboarding"
+type MoveSheetState = { source: RailEntity; focusTarget: HTMLElement } | null
+
+function reconcileCreatedFolders(
+ state: RailState,
+ createdFolderIds: Record<string, string>,
+): RailState {
+ if (Object.keys(createdFolderIds).length === 0) return state
+ return {
+ ...state,
+ folderOrder: state.folderOrder.map((id) => createdFolderIds[id] ?? id),
+ folders: Object.fromEntries(Object.entries(state.folders).map(([id, serverIds]) => [
+ createdFolderIds[id] ?? id,
+ serverIds,
+ ])),
+ expanded: [...new Set([
+ ...state.expanded.map((id) => createdFolderIds[id] ?? id),
+ ...Object.values(createdFolderIds),
+ ])],
+ }
+}
+
export const ServerRail = memo(function ServerRail({
- servers, folders, activeServerId: activeServerIdProp, serversLoading, view, bottomInset,
- onHome, onHomePrefetch, onServer, onServerNavigate, onServerPrefetch, onCreateServer, onLeaveServer,
- onOpenSettings, onOpenInvitePopover, onUngroupFolder, onReorderRail, onReorderFolders, onFolderItemsChange, onDragCreateFolder,
+ servers,
+ folders,
+ activeServerId: activeServerIdProp,
+ serversLoading,
+ view,
+ bottomInset,
+ onHome,
+ onHomePrefetch,
+ onServer,
+ onServerNavigate,
+ onServerPrefetch,
+ onCreateServer,
+ onLeaveServer,
+ onOpenSettings,
+ onOpenInvitePopover,
}: {
servers: Server[]
folders: CommunityFolder[]
@@ -44,49 +86,242 @@ export const ServerRail = memo(function ServerRail({
onLeaveServer?: (id: string) => void
onOpenSettings?: (serverId: string) => void
onOpenInvitePopover?: (serverId: string) => void
- onUngroupFolder?: (folderId: string) => void
- onReorderRail?: (serverIds: string[]) => void
- onReorderFolders?: (folderIds: string[]) => void
- onFolderItemsChange?: (folderId: string, serverIds: string[]) => void
- onDragCreateFolder?: (serverIdA: string, serverIdB: string) => void
}) {
- const railIds = useMemo(() => servers.map((s) => s.id), [servers])
+ const [state, setState] = useState<RailState>(() =>
+ railStateFromData(servers.map((server) => server.id), folders, []),
+ )
+ const [preview, setPreview] = useState<RailInstruction | null>(null)
+ const [dragSource, setDragSource] = useState<RailEntity | null>(null)
+ const [moveSheet, setMoveSheet] = useState<MoveSheetState>(null)
+ const [createOpen, setCreateOpen] = useState(false)
+ const scrollRef = useRef<HTMLDivElement>(null)
+ const dragSnapshotRef = useRef<RailState | null>(null)
+ const stateRef = useRef(state)
+ const mutationPendingRef = useRef(false)
+ const railMutation = useServerRailCommit()
- const {
- visibleItems, sortableIds, openFolders, toggleFolder,
- onDragStart: hookDragStart, onDragOver, onDragEnd: hookDragEnd, groupTarget,
- } = useRailOrder(railIds, folders, {
- onReorderRail, onReorderFolders, onFolderItemsChange, onCreateFolder: onDragCreateFolder,
- })
+ const claimMutation = useCallback(() => {
+ if (mutationPendingRef.current) {
+ announce("A server rail move is already being saved")
+ return false
+ }
+ mutationPendingRef.current = true
+ return true
+ }, [])
+ const releaseMutation = useCallback(() => {
+ mutationPendingRef.current = false
+ }, [])
- const [dragActiveId, setDragActiveId] = useState<string | null>(null)
- const onDragStart = (e: Parameters<typeof hookDragStart>[0]) => {
- setDragActiveId(String(e.active.id))
- hookDragStart(e)
- }
- const onDragEnd = (e: Parameters<typeof hookDragEnd>[0]) => {
- hookDragEnd(e)
- setDragActiveId(null)
- }
+ useEffect(() => {
+ stateRef.current = state
+ }, [state])
+
+ useEffect(() => {
+ try {
+ const saved = sessionStorage.getItem("rail-open-folders")
+ if (!saved) return
+ const expanded = JSON.parse(saved) as string[]
+ setState((current) => ({
+ ...current,
+ expanded: expanded.filter((folderId) => current.folderOrder.includes(folderId)),
+ }))
+ } catch {}
+ }, [])
+
+ useEffect(() => {
+ setState((current) => railStateFromData(
+ servers.map((server) => server.id),
+ folders,
+ current.expanded,
+ ))
+ }, [folders, servers])
+
+ useEffect(() => {
+ sessionStorage.setItem("rail-open-folders", JSON.stringify(state.expanded))
+ }, [state.expanded])
- const activeFromProps = activeServerIdProp ?? servers.find((s) => s.active)?.id ?? ""
+ useEffect(() => () => cleanupLiveRegion(), [])
+
+ const activeFromProps = activeServerIdProp ?? servers.find((server) => server.active)?.id ?? ""
const [localActiveId, setLocalActiveId] = useState(activeFromProps)
const activeId = activeFromProps || localActiveId
useEffect(() => { if (activeFromProps) setLocalActiveId(activeFromProps) }, [activeFromProps])
+ const pickServer = (id: string) => {
+ setLocalActiveId(id)
+ onServer?.()
+ onServerNavigate?.(id)
+ }
- const [createOpen, setCreateOpen] = useState(false)
+ const serverById = useMemo(() => new Map(servers.map((server) => [server.id, server])), [servers])
+ const serverNames = useMemo(
+ () => new Map(servers.map((server) => [server.id, server.name])),
+ [servers],
+ )
+ const folderNames = useMemo(
+ () => new Map(folders.map((folder) => [folder.id, folder.name])),
+ [folders],
+ )
+
+ const focusEntity = useCallback((
+ entity: RailEntity,
+ options?: { preferred?: HTMLElement; afterReconcile?: boolean },
+ ) => {
+ const focusCurrentEntity = () => {
+ const testId = entity.kind === "server"
+ ? tid.serverIcon(entity.id)
+ : tid.serverRailFolder(entity.id)
+ document.querySelector<HTMLElement>(`[data-testid="${testId}"]`)?.focus()
+ }
+ requestAnimationFrame(() => {
+ if (options?.afterReconcile) {
+ requestAnimationFrame(focusCurrentEntity)
+ return
+ }
+ if (options?.preferred?.isConnected) options.preferred.focus()
+ else focusCurrentEntity()
+ })
+ }, [])
+
+ const applyInstruction = useCallback((
+ rawInstruction: RailInstruction,
+ before: RailState,
+ focusTarget?: HTMLElement,
+ ) => {
+ let instruction = rawInstruction
+ if (
+ instruction.operation === "combine"
+ && instruction.source.kind === "server"
+ && instruction.target.kind === "server"
+ && !instruction.newFolderId
+ ) {
+ instruction = { ...instruction, newFolderId: `temp_${crypto.randomUUID()}` }
+ }
+ const result = commitRailInstruction(before, instruction)
+ if (!result.applied) {
+ announce(result.reason)
+ focusEntity(instruction.source, { preferred: focusTarget })
+ return
+ }
+ if (!claimMutation()) return
+ const label = railMoveAnnouncement(instruction, { servers: serverNames, folders: folderNames })
+ setState(result.state)
+ railMutation.mutate(
+ { before, after: result.state, commands: result.commands },
+ {
+ onSuccess: (response) => {
+ setState((current) => reconcileCreatedFolders(current, response.createdFolderIds))
+ announce(label)
+ },
+ onError: () => {
+ setState(before)
+ announce(`${label} failed and was rolled back`)
+ },
+ onSettled: () => {
+ releaseMutation()
+ focusEntity(instruction.source, { afterReconcile: true })
+ },
+ },
+ )
+ }, [claimMutation, focusEntity, folderNames, railMutation, releaseMutation, serverNames])
- const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }))
- const pickServer = (id: string) => { setLocalActiveId(id); onServer?.(); onServerNavigate?.(id) }
+ const ungroupFolder = useCallback((folderId: string) => {
+ const before = cloneRailState(stateRef.current)
+ const after = cloneRailState(stateRef.current)
+ const firstServerId = before.folders[folderId]?.[0]
+ delete after.folders[folderId]
+ after.folderOrder = after.folderOrder.filter((id) => id !== folderId)
+ after.expanded = after.expanded.filter((id) => id !== folderId)
+ const commands = planRailPersistence(before, after)
+ if (commands.length !== 1) return
+ if (!claimMutation()) return
+ setState(after)
+ railMutation.mutate(
+ { before, after, commands },
+ {
+ onSuccess: () => announce("Group removed"),
+ onError: () => {
+ setState(before)
+ announce("Removing group failed and was rolled back")
+ },
+ onSettled: (_data, error) => {
+ releaseMutation()
+ focusEntity(error || !firstServerId
+ ? { kind: "folder", id: folderId }
+ : { kind: "server", id: firstServerId }, { afterReconcile: true })
+ },
+ },
+ )
+ }, [claimMutation, focusEntity, railMutation, releaseMutation])
- const serverById = useMemo(() => new Map(servers.map((s) => [s.id, s])), [servers])
- const folderById = useMemo(() => new Map(folders.map((f) => [f.id, f])), [folders])
- // All servers in folders (for lookup by id)
- const folderServerMap = useMemo(() => {
- const m = new Map<string, { id: string; name: string; initial: string; icon: string | null }>()
- for (const f of folders) for (const s of f.servers) m.set(s.id, { id: s.id, name: s.name, initial: s.initial, icon: s.icon ?? null })
- return m
- }, [folders])
+ const createSingleServerFolder = useCallback((serverId: string) => {
+ const before = cloneRailState(stateRef.current)
+ if (before.folderOrder.length >= MAX_SERVER_RAIL_FOLDERS) return
+ const after = cloneRailState(before)
+ const clientId = `temp_${crypto.randomUUID()}`
+ after.folderOrder.push(clientId)
+ after.folders[clientId] = [serverId]
+ after.expanded.push(clientId)
+ const commands = planRailPersistence(before, after)
+ if (!claimMutation()) return
+ setState(after)
+ railMutation.mutate(
+ { before, after, commands },
+ {
+ onSuccess: (response) => {
+ setState((current) => reconcileCreatedFolders(current, response.createdFolderIds))
+ announce("Group created")
+ },
+ onError: () => {
+ setState(before)
+ announce("Creating group failed and was rolled back")
+ },
+ onSettled: () => {
+ releaseMutation()
+ focusEntity({ kind: "server", id: serverId }, { afterReconcile: true })
+ },
+ },
+ )
+ }, [claimMutation, focusEntity, railMutation, releaseMutation])
+
+ const { registerItem } = useServerRailPdd({
+ scrollRef,
+ onDragStart: (source) => {
+ dragSnapshotRef.current = cloneRailState(state)
+ setDragSource(source)
+ },
+ onPreview: setPreview,
+ onDrop: (instruction) => {
+ const before = dragSnapshotRef.current ?? cloneRailState(state)
+ dragSnapshotRef.current = null
+ setDragSource(null)
+ applyInstruction(instruction, before)
+ },
+ onCancel: () => {
+ dragSnapshotRef.current = null
+ setDragSource(null)
+ },
+ onHoverExpand: (folderId) => {
+ setState((current) => current.expanded.includes(folderId)
+ ? current
+ : { ...current, expanded: [...current.expanded, folderId] })
+ },
+ })
+
+ const previewFor = (entity: RailEntity) => preview?.target.kind === entity.kind
+ && preview.target.id === entity.id
+ ? preview.operation
+ : null
+ const dragging = (entity: RailEntity) => dragSource?.kind === entity.kind
+ && dragSource.id === entity.id
+ const folderServers = (folderId: string): FolderServer[] => (state.folders[folderId] ?? [])
+ .map((serverId) => serverById.get(serverId))
+ .filter((server): server is Server => !!server)
+ .map((server) => ({
+ id: server.id,
+ name: server.name,
+ initial: server.initial,
+ icon: server.icon ?? null,
+ }))
return (
<nav aria-label="Server navigation" className="flex min-h-0 w-14 shrink-0 flex-col items-center overflow-hidden pt-2">
@@ -114,145 +349,83 @@ export const ServerRail = memo(function ServerRail({
</div>
<div
+ ref={scrollRef}
data-testid={tid.serverRailScroll}
className="min-h-0 w-full shrink overflow-y-auto overflow-x-clip py-2 thin-scrollbar scrollbar-none"
>
{serversLoading && servers.length === 0 && folders.length === 0 ? (
<ServerRailSkeleton />
) : (
- <DndContext id="d-rail" sensors={sensors} collisionDetection={closestCenter} modifiers={[restrictToVerticalAxis]} onDragStart={onDragStart} onDragOver={onDragOver} onDragEnd={onDragEnd} onDragCancel={() => setDragActiveId(null)}>
- <SortableContext items={sortableIds} strategy={verticalListSortingStrategy}>
- <div className="flex w-full flex-col items-center gap-2">
- {(() => {
- const elements: ReactNode[] = []
- let i = 0
- while (i < visibleItems.length) {
- const id = visibleItems[i]!
-
- if (isFolderKey(id)) {
- const fId = extractFolderId(id)
- const folder = folderById.get(fId)
- if (!folder) { i++; continue }
- const isOpen = openFolders.has(fId)
-
- elements.push(
- <RailFolder
- key={id}
- folderId={fId}
- sortableId={id}
- open={isOpen}
- onToggle={() => toggleFolder(fId)}
- activeId={activeId}
- folderServers={folder.servers}
- onUngroup={() => onUngroupFolder?.(fId)}
- dragging={dragActiveId === id}
- />
- )
-
- // Collect open folder's servers
- if (isOpen) {
- const folderItems: ReactNode[] = []
- let j = i + 1
- while (j < visibleItems.length && !isFolderKey(visibleItems[j]!) && folderServerMap.has(visibleItems[j]!)) {
- const sid = visibleItems[j]!
- const fs = folderServerMap.get(sid)!
- folderItems.push(
- <SortableServer
- key={sid}
- server={{ id: fs.id, name: fs.name, initial: fs.initial, icon: fs.icon, active: false, mentions: 0, isOwner: false }}
- active={view !== "dm" && activeId === sid}
- onClick={() => pickServer(sid)}
- onPrefetch={() => onServerPrefetch?.(sid)}
- onOpenSettings={() => onOpenSettings?.(sid)}
- onOpenInvitePopover={onOpenInvitePopover ? () => onOpenInvitePopover(sid) : undefined}
- inFolder
- dragging={dragActiveId === sid}
- />
- )
- j++
- }
- if (folderItems.length > 0) {
- elements.push(
- <div key={`fi-${fId}`} className="relative flex w-full flex-col items-center gap-2 py-1">
- <span className="pointer-events-none absolute inset-y-0 left-1/2 w-12 -translate-x-1/2 rounded-[20px] bg-primary/10" />
- {folderItems}
- </div>
- )
- }
- i = j
- } else {
- i++
- }
- } else {
- // Rail server
- const s = serverById.get(id)
- if (s) {
- elements.push(
- <SortableServer
- key={id}
- server={s}
- active={view !== "dm" && s.active}
- onClick={() => pickServer(id)}
- onPrefetch={() => onServerPrefetch?.(id)}
- onLeave={() => onLeaveServer?.(id)}
- onOpenSettings={() => onOpenSettings?.(id)}
- onOpenInvitePopover={onOpenInvitePopover ? () => onOpenInvitePopover(id) : undefined}
- onCreateFolder={folders.length < 10 ? () => onDragCreateFolder?.(id, id) : undefined}
- groupTarget={groupTarget === id}
- dragging={dragActiveId === id}
- />
- )
- }
- i++
- }
- }
- return elements
- })()}
- </div>
- </SortableContext>
- <DragOverlay dropAnimation={null}>
- {dragActiveId && (() => {
- if (isFolderKey(dragActiveId)) {
- const fId = extractFolderId(dragActiveId)
- const folder = folderById.get(fId)
- if (!folder) return null
+ <div className="flex w-full flex-col items-center gap-2">
+ {visibleTopLevelServers(state).map((serverId) => {
+ const server = serverById.get(serverId)
+ if (!server) return null
return (
- <div className="grid size-10 grid-cols-2 gap-1 rounded-xl bg-accent p-2 shadow-(--e2)">
- {Array.from({ length: 4 }).map((_, idx) => {
- const s = folder.servers[idx]
- return s ? (
- <span
- key={s.id}
- className={[
- "relative grid aspect-square place-items-center overflow-hidden rounded-sm font-brand text-[10px] font-semibold",
- s.icon ? "bg-card text-muted-foreground" : "text-white [text-shadow:0_1px_1px_rgb(0_0_0/0.35)]",
- ].join(" ")}
- >
- {s.icon ? <img src={s.icon} alt={s.name} className="size-full object-cover" /> : <><SeededBackdrop seed={s.id} /><span className="relative -translate-x-0.5 [-webkit-text-stroke:0.5px_currentColor]">{s.initial}</span></>}
- </span>
- ) : (
- <span key={idx} className="aspect-square rounded-sm bg-card/50" />
- )
- })}
- </div>
+ <SortableServer
+ key={serverId}
+ server={server}
+ active={view !== "dm" && activeId === serverId}
+ onClick={() => pickServer(serverId)}
+ onPrefetch={() => onServerPrefetch?.(serverId)}
+ onLeave={() => onLeaveServer?.(serverId)}
+ onOpenSettings={() => onOpenSettings?.(serverId)}
+ onOpenInvitePopover={onOpenInvitePopover ? () => onOpenInvitePopover(serverId) : undefined}
+ onCreateFolder={state.folderOrder.length < MAX_SERVER_RAIL_FOLDERS ? () => createSingleServerFolder(serverId) : undefined}
+ dragging={dragging({ kind: "server", id: serverId })}
+ preview={previewFor({ kind: "server", id: serverId })}
+ registerItem={registerItem}
+ onMove={(source, focusTarget) => setMoveSheet({ source, focusTarget })}
+ />
)
- }
- const s = serverById.get(dragActiveId) ?? folderServerMap.get(dragActiveId)
- if (!s) return null
- const icon = s.icon
+ })}
+ {state.folderOrder.map((folderId) => {
+ const serversInFolder = folderServers(folderId)
+ const open = state.expanded.includes(folderId)
+ && !(dragSource?.kind === "folder" && dragSource.id === folderId)
return (
- <div
- className={[
- "relative grid size-10 place-items-center overflow-hidden rounded-xl font-brand text-xl font-bold shadow-(--e2)",
- icon ? "bg-secondary text-foreground" : "text-white [text-shadow:0_1px_2px_rgb(0_0_0/0.35)]",
- ].join(" ")}
- >
- {icon ? <img src={icon} alt={s.name} className="size-full object-cover" /> : <><SeededBackdrop seed={s.id} /><span className="relative -translate-x-0.5 [-webkit-text-stroke:0.5px_currentColor]">{s.initial}</span></>}
+ <div key={folderId} className="flex w-full flex-col items-center gap-2">
+ <RailFolder
+ folderId={folderId}
+ open={open}
+ onToggle={() => setState((current) => ({
+ ...current,
+ expanded: current.expanded.includes(folderId)
+ ? current.expanded.filter((id) => id !== folderId)
+ : [...current.expanded, folderId],
+ }))}
+ activeId={activeId}
+ folderServers={serversInFolder}
+ onUngroup={() => ungroupFolder(folderId)}
+ dragging={dragging({ kind: "folder", id: folderId })}
+ preview={previewFor({ kind: "folder", id: folderId })}
+ registerItem={registerItem}
+ onMove={(source, focusTarget) => setMoveSheet({ source, focusTarget })}
+ />
+ {open && serversInFolder.length > 0 && (
+ <div className="relative flex w-full flex-col items-center gap-2 py-1">
+ <span className="pointer-events-none absolute inset-y-0 left-1/2 w-12 -translate-x-1/2 rounded-[20px] bg-primary/10" />
+ {serversInFolder.map((server) => (
+ <SortableServer
+ key={server.id}
+ server={{ ...server, active: false, mentions: serverById.get(server.id)?.mentions ?? 0, isOwner: serverById.get(server.id)?.isOwner }}
+ active={view !== "dm" && activeId === server.id}
+ onClick={() => pickServer(server.id)}
+ onPrefetch={() => onServerPrefetch?.(server.id)}
+ onOpenSettings={() => onOpenSettings?.(server.id)}
+ onOpenInvitePopover={onOpenInvitePopover ? () => onOpenInvitePopover(server.id) : undefined}
+ inFolder
+ dragging={dragging({ kind: "server", id: server.id })}
+ preview={previewFor({ kind: "server", id: server.id })}
+ registerItem={registerItem}
+ onMove={(source, focusTarget) => setMoveSheet({ source, focusTarget })}
+ />
+ ))}
+ </div>
+ )}
</div>
)
- })()}
- </DragOverlay>
- </DndContext>
+ })}
+ </div>
)}
</div>
@@ -272,6 +445,19 @@ export const ServerRail = memo(function ServerRail({
/>
</div>
+ <ServerRailMoveMenu
+ source={moveSheet?.source ?? null}
+ state={state}
+ serverNames={serverNames}
+ folderNames={folderNames}
+ onClose={() => setMoveSheet(null)}
+ onMove={(instruction) => {
+ const focusTarget = moveSheet?.focusTarget
+ setMoveSheet(null)
+ applyInstruction(instruction, cloneRailState(state), focusTarget)
+ }}
+ />
+
{createOpen && (
<CreateServerDialog
onClose={() => setCreateOpen(false)}
@@ -282,14 +468,11 @@ export const ServerRail = memo(function ServerRail({
)
})
-// Loading placeholder for the vertical server rail. Reserves the size-10
-// square footprint of each <RailIcon> so the rail's width and rhythm don't
-// change once servers arrive.
function ServerRailSkeleton() {
return (
<div className="flex w-full flex-col items-center gap-2">
- {Array.from({ length: 4 }).map((_, i) => (
- <Skeleton key={i} className="size-10 rounded-[20px]" />
+ {Array.from({ length: 4 }).map((_, index) => (
+ <Skeleton key={index} className="size-10 rounded-[20px]" />
))}
</div>
)
diff --git a/src/web/src/components/community/shell/sortable-server.focus.test.ts b/src/web/src/components/community/shell/sortable-server.focus.test.ts
new file mode 100644
index 000000000..47f01e563
--- /dev/null
+++ b/src/web/src/components/community/shell/sortable-server.focus.test.ts
@@ -0,0 +1,76 @@
+import { createElement, Fragment, type ReactNode } from "react"
+import TestRenderer, { act } from "react-test-renderer"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { SortableServer } from "./sortable-server"
+
+vi.mock("@/components/ui/context-menu", () => ({
+ ContextMenu: ({ children }: { children: ReactNode }) => createElement(Fragment, null, children),
+ ContextMenuTrigger: ({ render }: { render: ReactNode }) =>
+ createElement("context-menu-trigger", null, render),
+ ContextMenuContent: ({ children }: { children: ReactNode }) =>
+ createElement("context-menu-content", null, children),
+ ContextMenuItem: ({ children }: { children: ReactNode }) =>
+ createElement("context-menu-item", null, children),
+ ContextMenuSeparator: () => null,
+}))
+vi.mock("@/components/ui/tooltip", () => ({
+ Tooltip: ({ children }: { children: ReactNode }) => createElement(Fragment, null, children),
+ TooltipTrigger: ({ children }: { children: ReactNode }) => children,
+ TooltipContent: () => null,
+}))
+vi.mock("./rail-indicator", () => ({ RailIndicator: () => null }))
+vi.mock("@/components/ui/confirm-dialog", () => ({ ConfirmDialog: () => null }))
+vi.mock("@/components/ui/number-ticker", () => ({ NumberTicker: () => null }))
+vi.mock("@/components/avatar", () => ({ SeededBackdrop: () => null }))
+
+const server = {
+ id: "a",
+ name: "A",
+ initial: "A",
+ active: false,
+ mentions: 0,
+}
+
+function renderServer() {
+ const buttonNodes: Array<{ focus: ReturnType<typeof vi.fn> }> = []
+ const renderer = TestRenderer.create(createElement(SortableServer, {
+ server,
+ onClick: vi.fn(),
+ onMove: vi.fn(),
+ }), {
+ createNodeMock: (element) => {
+ if (element.type !== "button") return {}
+ const node = { focus: vi.fn() }
+ buttonNodes.push(node)
+ return node
+ },
+ })
+ const activationRoot = () => renderer.root.findAllByType("div")
+ .find((node) => typeof node.props.onFocusCapture === "function")!
+ return { renderer, buttonNodes, activationRoot }
+}
+
+describe("SortableServer lazy menu focus", () => {
+ beforeEach(() => vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true))
+ afterEach(() => vi.unstubAllGlobals())
+
+ it("refocuses the icon after first focus activates and replaces its menu wrapper", async () => {
+ let result!: ReturnType<typeof renderServer>
+ await act(async () => { result = renderServer() })
+
+ await act(async () => result.activationRoot().props.onFocusCapture())
+
+ expect(result.renderer.root.findAllByType("context-menu-trigger")).toHaveLength(1)
+ expect(result.buttonNodes.at(-1)?.focus).toHaveBeenCalledTimes(1)
+ })
+
+ it("does not steal focus when pointer hover activates the menu", async () => {
+ let result!: ReturnType<typeof renderServer>
+ await act(async () => { result = renderServer() })
+
+ await act(async () => result.activationRoot().props.onPointerEnter())
+
+ expect(result.renderer.root.findAllByType("context-menu-trigger")).toHaveLength(1)
+ expect(result.buttonNodes.every((node) => node.focus.mock.calls.length === 0)).toBe(true)
+ })
+})
diff --git a/src/web/src/components/community/shell/sortable-server.tsx b/src/web/src/components/community/shell/sortable-server.tsx
index 0e32e7ba5..a86b143f7 100644
--- a/src/web/src/components/community/shell/sortable-server.tsx
+++ b/src/web/src/components/community/shell/sortable-server.tsx
@@ -1,8 +1,6 @@
"use client";
-import { memo, useState } from "react";
-import { useSortable } from "@dnd-kit/sortable";
-import { CSS } from "@dnd-kit/utilities";
+import { memo, useEffect, useLayoutEffect, useRef, useState } from "react";
import {
ContextMenu,
ContextMenuTrigger,
@@ -21,6 +19,7 @@ import { NumberTicker } from "@/components/ui/number-ticker";
import { SeededBackdrop } from "@/components/avatar";
import { tid } from "@/lib/community/testids";
import type { Server } from "@/lib/community/models/navigation"
+import type { RailEntity, RailOperation } from "@/lib/community/server-rail-model"
type SortableServerProps = {
server: Server;
@@ -31,9 +30,15 @@ type SortableServerProps = {
onOpenSettings?: () => void;
onOpenInvitePopover?: () => void;
onCreateFolder?: () => void;
- groupTarget?: boolean;
inFolder?: boolean;
dragging?: boolean;
+ preview?: RailOperation | null;
+ registerItem?: (
+ entity: RailEntity,
+ element: HTMLElement,
+ dragHandle: HTMLElement,
+ ) => () => void;
+ onMove?: (source: RailEntity, focusTarget: HTMLElement) => void;
};
function SortableServerImpl({
@@ -45,30 +50,15 @@ function SortableServerImpl({
onOpenSettings,
onOpenInvitePopover,
onCreateFolder,
- groupTarget,
inFolder,
dragging: isDragActive,
+ preview,
+ registerItem,
+ onMove,
}: SortableServerProps) {
- const {
- attributes,
- listeners,
- setNodeRef,
- transform,
- transition,
- isDragging,
- isOver,
- activeIndex,
- index,
- } = useSortable({ id: server.id });
- const style = {
- transform: CSS.Transform.toString(transform),
- transition,
- opacity: isDragActive ? 0.3 : 1,
- zIndex: isDragging ? 10 : undefined,
- };
- const showLine = isOver && !isDragging && !isDragActive;
- const lineSide: "top" | "bottom" =
- activeIndex !== -1 && activeIndex < index ? "bottom" : "top";
+ const rootRef = useRef<HTMLDivElement>(null)
+ const buttonRef = useRef<HTMLButtonElement>(null)
+ const restoreFocusAfterActivationRef = useRef(false)
const [confirmLeave, setConfirmLeave] = useState(false);
// Lazy-mount the row's Base UI ContextMenu + ConfirmDialog. Eagerly mounting
// them per rail icon (one Tooltip + ContextMenu + Dialog stack × N servers)
@@ -80,43 +70,58 @@ function SortableServerImpl({
// and a right-click is always preceded by a pointerenter so the menu is
// mounted before it's invoked).
const [activated, setActivated] = useState(false);
+ useEffect(() => {
+ if (!registerItem || !rootRef.current || !buttonRef.current) return
+ return registerItem(
+ { kind: "server", id: server.id },
+ rootRef.current,
+ buttonRef.current,
+ )
+ }, [activated, registerItem, server.id])
+ useLayoutEffect(() => {
+ if (!activated || !restoreFocusAfterActivationRef.current) return
+ restoreFocusAfterActivationRef.current = false
+ buttonRef.current?.focus()
+ }, [activated])
const activate = activated ? undefined : () => setActivated(true);
const activateAndPrefetch = () => {
activate?.();
onPrefetch?.();
};
+ const activateFromFocus = () => {
+ if (!activated) restoreFocusAfterActivationRef.current = true
+ activateAndPrefetch()
+ };
const icon = (
<div
- ref={setNodeRef}
- style={style}
+ ref={rootRef}
+ style={{ opacity: isDragActive ? 0.3 : 1 }}
className="group relative flex w-full justify-center"
onPointerEnter={activateAndPrefetch}
- onFocusCapture={activateAndPrefetch}
+ onFocusCapture={activateFromFocus}
onKeyDownCapture={activate}
>
- {showLine && (
+ {(preview === "reorder-before" || preview === "reorder-after") && (
<div
- className={`pointer-events-none absolute inset-x-3 z-10 h-0.5 rounded-full bg-primary ${lineSide === "top" ? "-top-1" : "-bottom-1"}`}
+ data-testid={tid.serverRailInsert(server.id)}
+ className={`pointer-events-none absolute left-1/2 z-10 h-0.5 w-9 -translate-x-1/2 rounded-full bg-primary ${preview === "reorder-before" ? "-top-1" : "-bottom-1"}`}
/>
)}
<RailIndicator active={active} />
<div
className={[
- "relative size-10 transition-all duration-150",
- groupTarget ? "scale-110 rounded-xl ring-2 ring-primary" : "",
- isDragging
- ? "rounded-xl border-2 border-dashed border-muted-foreground/40"
- : "",
+ "relative size-10 transition-[border-radius,background-color,border-color,opacity,transform] duration-150",
+ preview === "combine" ? "rounded-xl bg-primary/10 outline outline-2! outline-primary" : "",
+ isDragActive ? "rounded-xl border-2 border-dashed border-muted-foreground/40" : "",
].join(" ")}
>
<button
+ ref={buttonRef}
data-testid={tid.serverIcon(server.id)}
onClick={active ? undefined : onClick}
- {...attributes}
- {...listeners}
className={[
- "relative grid size-10 touch-none place-items-center overflow-hidden font-brand text-xl font-bold transition-all duration-150 active:cursor-grabbing",
+ "relative grid size-10 touch-manipulation place-items-center overflow-hidden font-brand text-xl font-bold transition-all duration-150 active:cursor-grabbing",
active
? "cursor-default rounded-xl"
: "cursor-pointer rounded-[18px] hover:rounded-xl",
@@ -174,6 +179,13 @@ function SortableServerImpl({
Create group
</ContextMenuItem>
)}
+ {onMove && (
+ <ContextMenuItem onClick={() => {
+ if (buttonRef.current) onMove({ kind: "server", id: server.id }, buttonRef.current)
+ }}>
+ Move…
+ </ContextMenuItem>
+ )}
<ContextMenuItem onClick={onOpenSettings} data-testid={tid.serverSettingsOpen}>
Server settings
</ContextMenuItem>
@@ -229,9 +241,10 @@ function SortableServerImpl({
// each rail item passes fresh per-render arrow callbacks, so a default shallow
// memo would always see "new" and never bail out. We compare the `server`
// fields that actually change plus the derived layout props, and DELIBERATELY
-// ignore the callbacks: every one closes over only a stable id + a
-// shell-frame `useCallback`'d handler, so their identity churn carries no new
-// behavior. Without this, the whole rail (N servers × their Tooltip/Avatar)
+// ignore the callbacks: navigation callbacks close over a stable id + handler,
+// while structural callbacks read current state and pending status from refs.
+// Their identity churn therefore carries no new behavior. Without this, the
+// whole rail (N servers × their Tooltip/Avatar)
// re-renders on every tick — the SortableServer/TooltipTrigger ×N in
// perf:switch after the lazy-overlay pass.
function serverPropsEqual(prev: SortableServerProps, next: SortableServerProps): boolean {
@@ -245,15 +258,16 @@ function serverPropsEqual(prev: SortableServerProps, next: SortableServerProps):
a.mentions === b.mentions &&
a.isOwner === b.isOwner &&
prev.active === next.active &&
- prev.groupTarget === next.groupTarget &&
prev.inFolder === next.inFolder &&
prev.dragging === next.dragging &&
+ prev.preview === next.preview &&
// The presence of an optional handler flips menu items on/off, so compare
// definedness (not identity) — a menu row appears/disappears with it.
!!prev.onLeave === !!next.onLeave &&
!!prev.onOpenSettings === !!next.onOpenSettings &&
!!prev.onOpenInvitePopover === !!next.onOpenInvitePopover &&
!!prev.onCreateFolder === !!next.onCreateFolder &&
+ !!prev.onMove === !!next.onMove &&
!!prev.onPrefetch === !!next.onPrefetch
);
}
diff --git a/src/web/src/components/community/shell/use-rail-order.test.ts b/src/web/src/components/community/shell/use-rail-order.test.ts
deleted file mode 100644
index 26732dc77..000000000
--- a/src/web/src/components/community/shell/use-rail-order.test.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { folderId, isFolderKey, extractFolderId, FOLDER_PREFIX } from "./use-rail-order"
-
-describe("folder key helpers", () => {
- it("creates a folder key with prefix", () => {
- expect(folderId("abc")).toBe("folder:abc")
- })
-
- it("detects folder keys", () => {
- expect(isFolderKey("folder:abc")).toBe(true)
- expect(isFolderKey("server_123")).toBe(false)
- expect(isFolderKey("")).toBe(false)
- })
-
- it("extracts folder id from key", () => {
- expect(extractFolderId("folder:abc")).toBe("abc")
- expect(extractFolderId("folder:")).toBe("")
- })
-
- it("FOLDER_PREFIX is consistent", () => {
- expect(FOLDER_PREFIX).toBe("folder:")
- })
-})
diff --git a/src/web/src/components/community/shell/use-rail-order.ts b/src/web/src/components/community/shell/use-rail-order.ts
deleted file mode 100644
index 13271e524..000000000
--- a/src/web/src/components/community/shell/use-rail-order.ts
+++ /dev/null
@@ -1,383 +0,0 @@
-"use client"
-
-import { useCallback, useEffect, useRef, useState } from "react"
-import { arrayMove } from "@dnd-kit/sortable"
-import type { DragEndEvent, DragOverEvent, DragStartEvent } from "@dnd-kit/core"
-import type { CommunityFolder } from "@/lib/community/models/navigation"
-
-export const FOLDER_PREFIX = "folder:"
-export function folderId(id: string) { return `${FOLDER_PREFIX}${id}` }
-export function isFolderKey(key: string) { return key.startsWith(FOLDER_PREFIX) }
-export function extractFolderId(key: string) { return key.slice(FOLDER_PREFIX.length) }
-
-type Callbacks = {
- onReorderRail?: (serverIds: string[]) => void
- onReorderFolders?: (folderIds: string[]) => void
- onFolderItemsChange?: (folderId: string, serverIds: string[]) => void
- onCreateFolder?: (serverIdA: string, serverIdB: string) => void
-}
-
-const GROUP_DELAY = 300
-
-function computeRailOrder(railServerIds: string[], folders: CommunityFolder[]): string[] {
- const inFolder = new Set(folders.flatMap((f) => f.servers.map((s) => s.id)))
- const serverItems = railServerIds.filter((id) => !inFolder.has(id))
- const folderItems = [...folders].sort((a, b) => a.position - b.position).map((f) => folderId(f.id))
- return [...serverItems, ...folderItems]
-}
-
-/**
- * Multi-folder rail order hook.
- *
- * Rail order is a flat list of server ids and folder keys (folder:{id}).
- * Each folder can be open/closed independently.
- * When open, folder's servers are rendered inline after the folder key.
- */
-export function useRailOrder(
- railServerIds: string[],
- folders: CommunityFolder[],
- callbacks?: Callbacks,
-) {
- // Build initial rail order: servers not in any folder + folder keys sorted by position
- const folderServerSet = useRef(new Set<string>())
- const [railOrder, setRailOrder] = useState<string[]>(() => computeRailOrder(railServerIds, folders))
- const [openFolders, setOpenFolders] = useState<Set<string>>(new Set())
- const [groupTarget, setGroupTarget] = useState<string | null>(null)
-
- // Restore open state from sessionStorage after hydration, then persist changes
- const hydratedRef = useRef(false)
- useEffect(() => {
- if (!hydratedRef.current) {
- hydratedRef.current = true
- try {
- const saved = sessionStorage.getItem("rail-open-folders")
- if (saved) {
- const ids = JSON.parse(saved) as string[]
- if (ids.length > 0) setOpenFolders(new Set(ids))
- }
- } catch { /* ignore */ }
- return
- }
- sessionStorage.setItem("rail-open-folders", JSON.stringify([...openFolders]))
- }, [openFolders])
-
- const hoverTimerRef = useRef<NodeJS.Timeout | null>(null)
- const hoverTargetRef = useRef<string | null>(null)
- const groupTargetRef = useRef<string | null>(null)
- useEffect(() => { groupTargetRef.current = groupTarget }, [groupTarget])
-
- const clearHoverTimer = useCallback(() => {
- if (hoverTimerRef.current) { clearTimeout(hoverTimerRef.current); hoverTimerRef.current = null }
- hoverTargetRef.current = null
- }, [])
-
- // Folder internal orders (folderId → serverId[])
- const [folderOrders, setFolderOrders] = useState<Map<string, string[]>>(() => {
- const m = new Map<string, string[]>()
- for (const f of folders) m.set(f.id, f.servers.map((s) => s.id))
- return m
- })
-
- // Refs for sync reads during drag
- const railOrderRef = useRef(railOrder)
- useEffect(() => { railOrderRef.current = railOrder }, [railOrder])
- const folderOrdersRef = useRef(folderOrders)
- useEffect(() => { folderOrdersRef.current = folderOrders }, [folderOrders])
-
- // Sync from props
- const prevRailRef = useRef(railServerIds)
- const prevFoldersRef = useRef(folders)
- useEffect(() => {
- const pr = prevRailRef.current
- const pf = prevFoldersRef.current
- prevRailRef.current = railServerIds
- prevFoldersRef.current = folders
-
- const inFolder = new Set(folders.flatMap((f) => f.servers.map((s) => s.id)))
- folderServerSet.current = inFolder
-
- // Sync rail order: keep existing order, remove deleted, add new
- const prJoin = pr.join(",")
- const curJoin = railServerIds.join(",")
- const pfIds = pf.map((f) => f.id).join(",")
- const curFIds = folders.map((f) => f.id).join(",")
-
- if (prJoin !== curJoin || pfIds !== curFIds) {
- setRailOrder((current) => {
- const validServers = new Set(railServerIds.filter((id) => !inFolder.has(id)))
- const validFolderKeys = new Set(folders.map((f) => folderId(f.id)))
- const validSet = new Set([...validServers, ...validFolderKeys])
-
- // Keep existing items that are still valid
- const kept = current.filter((id) => validSet.has(id))
- const keptSet = new Set(kept)
-
- // Add new servers/folders not in current order
- const added = [...validSet].filter((id) => !keptSet.has(id))
- return [...kept, ...added]
- })
- }
-
- // Sync folder internal orders
- if (pfIds !== curFIds || pf.some((f, i) => {
- const cur = folders[i]
- return !cur || f.servers.map((s) => s.id).join(",") !== cur.servers.map((s) => s.id).join(",")
- })) {
- setFolderOrders((current) => {
- const next = new Map(current)
- for (const f of folders) {
- const propIds = f.servers.map((s) => s.id)
- const existing = next.get(f.id)
- if (!existing) {
- next.set(f.id, propIds)
- } else {
- // Keep order of existing, remove deleted, add new
- const propSet = new Set(propIds)
- const kept = existing.filter((id) => propSet.has(id))
- const keptSet = new Set(kept)
- const added = propIds.filter((id) => !keptSet.has(id))
- next.set(f.id, [...kept, ...added])
- }
- }
- // Remove folders no longer in props
- const validIds = new Set(folders.map((f) => f.id))
- for (const key of next.keys()) {
- if (!validIds.has(key)) next.delete(key)
- }
- return next
- })
- }
- }, [railServerIds, folders])
-
- // Which folder does a server id belong to?
- const getServerFolder = useCallback((serverId: string): string | null => {
- for (const [fId, ids] of folderOrdersRef.current) {
- if (ids.includes(serverId)) return fId
- }
- return null
- }, [])
-
- // --- Drag handlers ---
-
- const [reopenAfterDrag, setReopenAfterDrag] = useState<string | null>(null)
-
- const onDragStart = (e: DragStartEvent) => {
- const id = String(e.active.id)
- // If dragging an open folder, close it temporarily
- if (isFolderKey(id) && openFolders.has(extractFolderId(id))) {
- setReopenAfterDrag(extractFolderId(id))
- setOpenFolders((s) => { const n = new Set(s); n.delete(extractFolderId(id)); return n })
- }
- }
-
- const onDragOver = (e: DragOverEvent) => {
- const { active, over } = e
- if (!over) { clearHoverTimer(); setGroupTarget(null); return }
- const activeId = String(active.id)
- const overId = String(over.id)
- if (activeId === overId) { clearHoverTimer(); setGroupTarget(null); return }
-
- const activeInRail = railOrderRef.current.includes(activeId)
- const overInRail = railOrderRef.current.includes(overId)
- const activeFolder = getServerFolder(activeId)
- const overFolder = getServerFolder(overId)
-
- // Rail server dragged over a folder server → move into that folder
- if (activeInRail && !isFolderKey(activeId) && overFolder) {
- const newRail = railOrderRef.current.filter((id) => id !== activeId)
- railOrderRef.current = newRail
- setRailOrder(newRail)
- setFolderOrders((m) => {
- const next = new Map(m)
- const arr = [...(next.get(overFolder) ?? [])]
- if (!arr.includes(activeId)) {
- const idx = arr.indexOf(overId)
- arr.splice(idx >= 0 ? idx : arr.length, 0, activeId)
- }
- next.set(overFolder, arr)
- return next
- })
- folderOrdersRef.current = new Map(folderOrdersRef.current).set(overFolder, [...(folderOrdersRef.current.get(overFolder) ?? []), activeId])
- clearHoverTimer(); setGroupTarget(null)
- return
- }
-
- // Folder server dragged over a rail item → move out of folder
- if (activeFolder && overInRail && !isFolderKey(overId)) {
- setFolderOrders((m) => {
- const next = new Map(m)
- next.set(activeFolder, (next.get(activeFolder) ?? []).filter((id) => id !== activeId))
- return next
- })
- const newRail = [...railOrderRef.current]
- if (!newRail.includes(activeId)) {
- const idx = newRail.indexOf(overId)
- newRail.splice(idx >= 0 ? idx : newRail.length, 0, activeId)
- }
- railOrderRef.current = newRail
- setRailOrder(newRail)
- clearHoverTimer(); setGroupTarget(null)
- return
- }
-
- // Rail server dragged over a folder key → move into that folder
- if (activeInRail && !isFolderKey(activeId) && isFolderKey(overId)) {
- const targetFId = extractFolderId(overId)
- const newRail = railOrderRef.current.filter((id) => id !== activeId)
- railOrderRef.current = newRail
- setRailOrder(newRail)
- setFolderOrders((m) => {
- const next = new Map(m)
- const arr = [...(next.get(targetFId) ?? [])]
- if (!arr.includes(activeId)) arr.push(activeId)
- next.set(targetFId, arr)
- return next
- })
- clearHoverTimer(); setGroupTarget(null)
- return
- }
-
- // Group-create hover: rail server onto another rail server (both not in folders, no folder keys)
- if (activeInRail && overInRail && !isFolderKey(activeId) && !isFolderKey(overId)) {
- if (hoverTargetRef.current === overId) return
- clearHoverTimer()
- setGroupTarget(null)
- hoverTargetRef.current = overId
- hoverTimerRef.current = setTimeout(() => {
- setGroupTarget(overId)
- groupTargetRef.current = overId
- }, GROUP_DELAY)
- return
- }
-
- clearHoverTimer()
- if (groupTarget) setGroupTarget(null)
- }
-
- const onDragEnd = (e: DragEndEvent) => {
- const { active, over } = e
- clearHoverTimer()
- const pendingGroup = groupTargetRef.current
- setGroupTarget(null)
-
- if (reopenAfterDrag) {
- setOpenFolders((s) => new Set(s).add(reopenAfterDrag))
- setReopenAfterDrag(null)
- }
-
- if (!over || active.id === over.id) {
- persistState()
- return
- }
-
- const activeId = String(active.id)
- const overId = String(over.id)
-
- // Folder group creation
- if (pendingGroup && pendingGroup === overId && callbacks?.onCreateFolder) {
- callbacks.onCreateFolder(activeId, overId)
- return
- }
-
- // Within-rail reorder
- const endActiveInRail = railOrderRef.current.includes(activeId)
- const endOverInRail = railOrderRef.current.includes(overId)
- if (endActiveInRail && endOverInRail) {
- const from = railOrderRef.current.indexOf(activeId)
- const to = railOrderRef.current.indexOf(overId)
- if (from !== -1 && to !== -1) {
- const newRail = arrayMove(railOrderRef.current, from, to)
- railOrderRef.current = newRail
- setRailOrder(newRail)
- }
- }
-
- // Within same folder reorder
- const activeFolder = getServerFolder(activeId)
- const overFolder = getServerFolder(overId)
- if (activeFolder && activeFolder === overFolder) {
- setFolderOrders((m) => {
- const next = new Map(m)
- const arr = [...(next.get(activeFolder) ?? [])]
- const from = arr.indexOf(activeId)
- const to = arr.indexOf(overId)
- if (from !== -1 && to !== -1) {
- next.set(activeFolder, arrayMove(arr, from, to))
- }
- return next
- })
- }
-
- persistState()
- }
-
- // Persist to callbacks
- const prevPersistedRailRef = useRef<string[]>([])
- const prevPersistedFoldersRef = useRef<Map<string, string[]>>(new Map())
-
- const persistState = useCallback(() => {
- const rail = railOrderRef.current
- const serverIds = rail.filter((id) => !isFolderKey(id))
- const folderKeys = rail.filter((id) => isFolderKey(id)).map(extractFolderId)
-
- // Persist rail server order
- if (serverIds.join(",") !== prevPersistedRailRef.current.join(",")) {
- prevPersistedRailRef.current = serverIds
- callbacks?.onReorderRail?.(serverIds)
- }
-
- // Persist folder order in rail
- if (folderKeys.length > 0) {
- callbacks?.onReorderFolders?.(folderKeys)
- }
-
- // Persist each folder's internal order
- for (const [fId, order] of folderOrdersRef.current) {
- const prev = prevPersistedFoldersRef.current.get(fId)
- if (!prev || prev.join(",") !== order.join(",")) {
- prevPersistedFoldersRef.current.set(fId, order)
- callbacks?.onFolderItemsChange?.(fId, order)
- }
- }
- // eslint-disable-next-line react-hooks/exhaustive-deps
- }, [])
-
- // Build visible items
- const visibleItems: string[] = []
- const seen = new Set<string>()
- for (const id of railOrder) {
- if (seen.has(id)) continue
- seen.add(id)
- visibleItems.push(id)
- if (isFolderKey(id) && openFolders.has(extractFolderId(id))) {
- const fId = extractFolderId(id)
- const order = folderOrders.get(fId) ?? []
- for (const sid of order) {
- if (seen.has(sid)) continue
- seen.add(sid)
- visibleItems.push(sid)
- }
- }
- }
-
- const toggleFolder = useCallback((fId: string) => {
- setOpenFolders((s) => {
- const next = new Set(s)
- if (next.has(fId)) next.delete(fId)
- else next.add(fId)
- return next
- })
- }, [])
-
- return {
- visibleItems,
- sortableIds: visibleItems,
- openFolders,
- toggleFolder,
- folderOrders,
- onDragStart,
- onDragOver,
- onDragEnd,
- groupTarget,
- }
-}
diff --git a/src/web/src/components/community/shell/use-server-rail-pdd.test.ts b/src/web/src/components/community/shell/use-server-rail-pdd.test.ts
new file mode 100644
index 000000000..a3da968c6
--- /dev/null
+++ b/src/web/src/components/community/shell/use-server-rail-pdd.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest"
+import { attachInstruction } from "@atlaskit/pragmatic-drag-and-drop-hitbox/list-item"
+import { railEntityFromData, railInstructionFromRecords } from "./use-server-rail-pdd"
+
+describe("server rail PDD record adapter", () => {
+ it("reads only typed rail entities", () => {
+ expect(railEntityFromData({ railKind: "server", railId: "one" })).toEqual({
+ kind: "server",
+ id: "one",
+ })
+ expect(railEntityFromData({ railKind: "channel", railId: "one" })).toBeNull()
+ })
+
+ it("extracts one before/after/combine instruction from the foremost target", () => {
+ const targetData = attachInstruction(
+ { railKind: "folder", railId: "group" },
+ {
+ input: { clientX: 20, clientY: 20 } as any,
+ element: {
+ getBoundingClientRect: () => ({ top: 0, bottom: 40, height: 40 }),
+ } as HTMLElement,
+ axis: "vertical",
+ operations: {
+ "reorder-before": "not-available",
+ "reorder-after": "not-available",
+ combine: "available",
+ },
+ },
+ )
+ expect(railInstructionFromRecords(
+ { railKind: "server", railId: "one" },
+ [{ data: targetData }],
+ )).toEqual({
+ operation: "combine",
+ source: { kind: "server", id: "one" },
+ target: { kind: "folder", id: "group" },
+ })
+ })
+
+ it("rejects self and missing targets", () => {
+ expect(railInstructionFromRecords({ railKind: "server", railId: "one" }, [])).toBeNull()
+ })
+})
diff --git a/src/web/src/components/community/shell/use-server-rail-pdd.ts b/src/web/src/components/community/shell/use-server-rail-pdd.ts
new file mode 100644
index 000000000..36cd78555
--- /dev/null
+++ b/src/web/src/components/community/shell/use-server-rail-pdd.ts
@@ -0,0 +1,178 @@
+"use client"
+
+import { useCallback, useEffect, useRef, type RefObject } from "react"
+import { autoScrollForElements } from "@atlaskit/pragmatic-drag-and-drop-auto-scroll/element"
+import {
+ attachInstruction,
+ extractInstruction,
+ type Availability,
+} from "@atlaskit/pragmatic-drag-and-drop-hitbox/list-item"
+import {
+ draggable,
+ dropTargetForElements,
+ monitorForElements,
+} from "@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter"
+import type { RailEntity, RailInstruction } from "@/lib/community/server-rail-model"
+
+type RailData = Record<string | symbol, unknown>
+
+function sameEntity(left: RailEntity | null, right: RailEntity | null): boolean {
+ return left?.kind === right?.kind && left?.id === right?.id
+}
+
+export function railEntityFromData(data: RailData): RailEntity | null {
+ const kind = data.railKind
+ const id = data.railId
+ if ((kind !== "server" && kind !== "folder") || typeof id !== "string") return null
+ return { kind, id }
+}
+
+export function railInstructionFromRecords(
+ sourceData: RailData,
+ targets: readonly { data: RailData }[],
+): RailInstruction | null {
+ const source = railEntityFromData(sourceData)
+ const targetRecord = targets[0]
+ if (!source || !targetRecord) return null
+ const target = railEntityFromData(targetRecord.data)
+ const instruction = extractInstruction(targetRecord.data)
+ if (!target || !instruction || instruction.blocked || sameEntity(source, target)) return null
+ return { operation: instruction.operation, source, target }
+}
+
+function operationAvailability(source: RailEntity | null, target: RailEntity): {
+ "reorder-before": Availability
+ "reorder-after": Availability
+ combine: Availability
+} {
+ const canReorder = source?.kind === target.kind
+ const canCombine = source?.kind === "server"
+ && (target.kind === "server" || target.kind === "folder")
+ return {
+ "reorder-before": canReorder ? "available" : "not-available",
+ "reorder-after": canReorder ? "available" : "not-available",
+ combine: canCombine ? "available" : "not-available",
+ }
+}
+
+function sameInstruction(left: RailInstruction | null, right: RailInstruction | null): boolean {
+ return left?.operation === right?.operation
+ && sameEntity(left?.source ?? null, right?.source ?? null)
+ && sameEntity(left?.target ?? null, right?.target ?? null)
+}
+
+export function useServerRailPdd({
+ scrollRef,
+ onDragStart,
+ onPreview,
+ onDrop,
+ onCancel,
+ onHoverExpand,
+}: {
+ scrollRef: RefObject<HTMLElement | null>
+ onDragStart: (source: RailEntity) => void
+ onPreview: (instruction: RailInstruction | null) => void
+ onDrop: (instruction: RailInstruction) => void
+ onCancel: () => void
+ onHoverExpand: (folderId: string) => void
+}) {
+ const handlersRef = useRef({ onDragStart, onPreview, onDrop, onCancel, onHoverExpand })
+ useEffect(() => {
+ handlersRef.current = { onDragStart, onPreview, onDrop, onCancel, onHoverExpand }
+ }, [onCancel, onDragStart, onDrop, onHoverExpand, onPreview])
+ const previewRef = useRef<RailInstruction | null>(null)
+ const hoverTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+ const hoverFolderRef = useRef<string | null>(null)
+
+ const clearHover = useCallback(() => {
+ if (hoverTimerRef.current) clearTimeout(hoverTimerRef.current)
+ hoverTimerRef.current = null
+ hoverFolderRef.current = null
+ }, [])
+
+ const updatePreview = useCallback((instruction: RailInstruction | null) => {
+ if (sameInstruction(previewRef.current, instruction)) return
+ previewRef.current = instruction
+ handlersRef.current.onPreview(instruction)
+ const folderId = instruction?.operation === "combine" && instruction.target.kind === "folder"
+ ? instruction.target.id
+ : null
+ if (!folderId) {
+ clearHover()
+ return
+ }
+ if (hoverFolderRef.current === folderId && hoverTimerRef.current) return
+ clearHover()
+ hoverFolderRef.current = folderId
+ hoverTimerRef.current = setTimeout(() => {
+ handlersRef.current.onHoverExpand(folderId)
+ hoverTimerRef.current = null
+ }, 500)
+ }, [clearHover])
+
+ const registerItem = useCallback((
+ entity: RailEntity,
+ element: HTMLElement,
+ dragHandle: HTMLElement,
+ ) => {
+ const cleanupDraggable = draggable({
+ element,
+ dragHandle,
+ getInitialData: () => ({ railKind: entity.kind, railId: entity.id }),
+ })
+ const cleanupTarget = dropTargetForElements({
+ element,
+ canDrop: ({ source }) => !sameEntity(railEntityFromData(source.data), entity),
+ getIsSticky: () => false,
+ getData: ({ input, element: targetElement, source }) => attachInstruction(
+ { railKind: entity.kind, railId: entity.id },
+ {
+ input,
+ element: targetElement,
+ axis: "vertical",
+ operations: operationAvailability(railEntityFromData(source.data), entity),
+ },
+ ),
+ })
+ return () => {
+ cleanupTarget()
+ cleanupDraggable()
+ }
+ }, [])
+
+ useEffect(() => monitorForElements({
+ canMonitor: ({ source }) => railEntityFromData(source.data) !== null,
+ onDragStart: ({ source }) => {
+ const entity = railEntityFromData(source.data)
+ if (entity) handlersRef.current.onDragStart(entity)
+ },
+ onDrag: ({ source, location }) => {
+ updatePreview(railInstructionFromRecords(source.data, location.current.dropTargets))
+ },
+ onDropTargetChange: ({ source, location }) => {
+ updatePreview(railInstructionFromRecords(source.data, location.current.dropTargets))
+ },
+ onDrop: ({ source, location }) => {
+ const instruction = railInstructionFromRecords(source.data, location.current.dropTargets)
+ clearHover()
+ previewRef.current = null
+ handlersRef.current.onPreview(null)
+ if (instruction) handlersRef.current.onDrop(instruction)
+ else handlersRef.current.onCancel()
+ },
+ }), [clearHover, updatePreview])
+
+ useEffect(() => {
+ const element = scrollRef.current
+ if (!element) return
+ return autoScrollForElements({
+ element,
+ getAllowedAxis: () => "vertical",
+ getConfiguration: () => ({ maxScrollSpeed: "fast" }),
+ })
+ }, [scrollRef])
+
+ useEffect(() => () => clearHover(), [clearHover])
+
+ return { registerItem }
+}
diff --git a/src/web/src/components/community/shell/use-shell-rail-controller.test.ts b/src/web/src/components/community/shell/use-shell-rail-controller.test.ts
index 057b02a26..457ced96e 100644
--- a/src/web/src/components/community/shell/use-shell-rail-controller.test.ts
+++ b/src/web/src/components/community/shell/use-shell-rail-controller.test.ts
@@ -5,15 +5,10 @@ import { useShellRailController } from "./use-shell-rail-controller"
const mocks = vi.hoisted(() => ({
servers: [{ id: "s1", name: "One" }, { id: "s2", name: "Two" }],
- folders: [],
+ folders: [] as Array<{ id: string; name: string; position: number; servers: Array<{ id: string }> }>,
createServer: vi.fn(),
leaveServer: vi.fn(),
uploadIcon: vi.fn(),
- deleteFolder: vi.fn(),
- reorderServers: vi.fn(),
- reorderFolders: vi.fn(),
- updateFolderItems: vi.fn(),
- createFolder: vi.fn(),
markVoluntaryLeave: vi.fn(),
markSwitch: vi.fn(),
toast: vi.fn(),
@@ -40,11 +35,6 @@ vi.mock("@/hooks/community/mutations", () => ({
useCreateServer: () => ({ mutateAsync: mocks.createServer }),
useLeaveServer: () => ({ mutate: mocks.leaveServer }),
useUploadServerIcon: () => ({ mutate: mocks.uploadIcon }),
- useDeleteServerFolder: () => ({ mutate: mocks.deleteFolder }),
- useReorderServers: () => ({ mutate: mocks.reorderServers }),
- useReorderFolders: () => ({ mutate: mocks.reorderFolders }),
- useUpdateFolderItems: () => ({ mutate: mocks.updateFolderItems }),
- useCreateServerFolderWith: () => ({ mutate: mocks.createFolder }),
}))
vi.mock("@/stores/community", () => ({
useCommunityStore: (selector: (state: { currentServerId: string }) => unknown) =>
@@ -136,6 +126,7 @@ describe("useShellRailController", () => {
for (const mock of Object.values(mocks)) {
if (typeof mock === "function" && "mockReset" in mock) mock.mockReset()
}
+ mocks.folders.length = 0
mocks.lastMeLeaf.current = null
})
@@ -363,50 +354,17 @@ describe("useShellRailController", () => {
expect(mocks.toastApiError).toHaveBeenCalledWith(leaveError, "Failed to leave server")
})
- it("preserves folder and ordering mutation payloads and toast callbacks", async () => {
- const hook = await renderController()
- await act(async () => {
- hook.current.railProps.onUngroupFolder("f1")
- hook.current.railProps.onReorderRail(["s2", "s1"])
- hook.current.railProps.onReorderFolders(["f2", "f1"])
- hook.current.railProps.onFolderItemsChange("f1", ["s1", "s2"])
- hook.current.railProps.onDragCreateFolder("s1", "s2")
+ it("passes complete memberships to the normalized rail and no legacy mutation callbacks", async () => {
+ mocks.folders.push({
+ id: "f1",
+ name: "Group",
+ position: 0,
+ servers: [{ id: "s2" }],
})
-
- expect(mocks.deleteFolder).toHaveBeenCalledWith(
- { folderId: "f1" },
- expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
- )
- expect(mocks.reorderServers).toHaveBeenCalledWith(
- { serverIds: ["s2", "s1"] },
- expect.objectContaining({ onError: expect.any(Function) }),
- )
- expect(mocks.reorderFolders).toHaveBeenCalledWith(
- { folderIds: ["f2", "f1"] },
- expect.objectContaining({ onError: expect.any(Function) }),
- )
- expect(mocks.updateFolderItems).toHaveBeenCalledWith(
- { folderId: "f1", serverIds: ["s1", "s2"] },
- expect.objectContaining({ onError: expect.any(Function) }),
- )
- expect(mocks.createFolder).toHaveBeenCalledWith(
- { serverIdA: "s1", serverIdB: "s2" },
- expect.objectContaining({ onError: expect.any(Function) }),
- )
-
- mocks.deleteFolder.mock.calls[0]![1].onSuccess()
- expect(mocks.toast).toHaveBeenLastCalledWith("Group removed")
- const cases = [
- [mocks.deleteFolder, "Failed to remove group"],
- [mocks.reorderServers, "Failed to save server order"],
- [mocks.reorderFolders, "Failed to reorder groups"],
- [mocks.updateFolderItems, "Failed to update group"],
- [mocks.createFolder, "Failed to create group"],
- ] as const
- for (const [mutation, message] of cases) {
- const error = new Error(message)
- mutation.mock.calls[0]![1].onError(error)
- expect(mocks.toastApiError).toHaveBeenLastCalledWith(error, message)
- }
+ const hook = await renderController()
+ expect(hook.current.railProps.servers.map((server) => server.id)).toEqual(["s1", "s2"])
+ expect(hook.current.railProps.folders).toEqual(mocks.folders)
+ expect(hook.current.railProps).not.toHaveProperty("onReorderRail")
+ expect(hook.current.railProps).not.toHaveProperty("onFolderItemsChange")
})
})
diff --git a/src/web/src/components/community/shell/use-shell-rail-controller.ts b/src/web/src/components/community/shell/use-shell-rail-controller.ts
index df8e3df29..a5ad94c2c 100644
--- a/src/web/src/components/community/shell/use-shell-rail-controller.ts
+++ b/src/web/src/components/community/shell/use-shell-rail-controller.ts
@@ -12,11 +12,6 @@ import {
useCreateServer,
useLeaveServer,
useUploadServerIcon,
- useDeleteServerFolder,
- useReorderServers,
- useReorderFolders,
- useUpdateFolderItems,
- useCreateServerFolderWith,
} from "@/hooks/community/mutations"
import { getLastChannel, pickServerLandingHref } from "@/lib/community/last-channel"
import { getLastMeLeaf, ME_ROOT, pickMeLandingLocation } from "@/lib/community/last-me-location"
@@ -57,22 +52,10 @@ export function useShellRailController({
const { mutateAsync: createServerAsync } = useCreateServer()
const { mutate: leaveServerMutate } = useLeaveServer()
const { mutate: uploadServerIconMutate } = useUploadServerIcon()
- const { mutate: deleteFolderMutate } = useDeleteServerFolder()
- const { mutate: reorderServersMutate } = useReorderServers()
- const { mutate: reorderFoldersMutate } = useReorderFolders()
- const { mutate: updateFolderItemsMutate } = useUpdateFolderItems()
- const { mutate: createFolderWithMutate } = useCreateServerFolderWith()
-
- const folderServerIds = useMemo(() => {
- const ids = new Set<string>()
- for (const folder of folders) for (const server of folder.servers) ids.add(server.id)
- return ids
- }, [folders])
const railServers = useMemo(
() => servers
- .filter((server) => !folderServerIds.has(server.id))
.map((server) => ({ ...server, active: server.id === projectedActiveServerId })),
- [folderServerIds, projectedActiveServerId, servers],
+ [projectedActiveServerId, servers],
)
const serverDestination = useCallback((id: string) => {
@@ -171,37 +154,6 @@ export function useShellRailController({
if (action.kind === "open-active") onOpenActiveServerInvite?.()
else navigation.push(action.href)
}, [activeServerId, navigation, onOpenActiveServerInvite])
- const onUngroupFolder = useCallback((folderId: string) => {
- deleteFolderMutate(
- { folderId },
- { onSuccess: () => toast("Group removed"), onError: (error) => toastApiError(error, "Failed to remove group") },
- )
- }, [deleteFolderMutate])
- const onReorderRail = useCallback((serverIds: string[]) => {
- reorderServersMutate(
- { serverIds },
- { onError: (error) => toastApiError(error, "Failed to save server order") },
- )
- }, [reorderServersMutate])
- const onReorderFolders = useCallback((folderIds: string[]) => {
- reorderFoldersMutate(
- { folderIds },
- { onError: (error) => toastApiError(error, "Failed to reorder groups") },
- )
- }, [reorderFoldersMutate])
- const onFolderItemsChange = useCallback((folderId: string, serverIds: string[]) => {
- updateFolderItemsMutate(
- { folderId, serverIds },
- { onError: (error) => toastApiError(error, "Failed to update group") },
- )
- }, [updateFolderItemsMutate])
- const onDragCreateFolder = useCallback((serverIdA: string, serverIdB: string) => {
- createFolderWithMutate(
- { serverIdA, serverIdB },
- { onError: (error) => toastApiError(error, "Failed to create group") },
- )
- }, [createFolderWithMutate])
-
const navigate = useCallback((serverId: string, channelId?: string) => {
markSwitch(channelId ? "channel" : "server", channelId ?? serverId)
if (channelId) {
@@ -226,11 +178,6 @@ export function useShellRailController({
onLeaveServer,
onOpenSettings,
onOpenInvitePopover,
- onUngroupFolder,
- onReorderRail,
- onReorderFolders,
- onFolderItemsChange,
- onDragCreateFolder,
},
navigate,
}
diff --git a/src/web/src/hooks/community/mutations/channels.test.ts b/src/web/src/hooks/community/mutations/channels.test.ts
index c08ede9b5..29bd30f9b 100644
--- a/src/web/src/hooks/community/mutations/channels.test.ts
+++ b/src/web/src/hooks/community/mutations/channels.test.ts
@@ -67,68 +67,6 @@ beforeEach(() => {
capturedQc = new QueryClient()
})
-describe("useReorderServers — cancels in-flight refetches before optimistic write", () => {
- it("calls cancelQueries with communityKeys.servers() before writing", async () => {
- capturedQc.setQueryData(communityKeys.servers(), {
- servers: [
- { id: "srv_1", name: "a", initial: "A", active: false, unread: false, mentions: 0 },
- { id: "srv_2", name: "b", initial: "B", active: false, unread: false, mentions: 0 },
- ],
- })
- apiFetchMock.mockResolvedValueOnce(undefined)
- const mod = await load()
- mod.useReorderServers()
-
- const cancelSpy = vi.spyOn(capturedQc, "cancelQueries")
- let cancelledBeforeWrite = false
- const originalSetQueryData = capturedQc.setQueryData.bind(capturedQc)
- vi.spyOn(capturedQc, "setQueryData").mockImplementation(((...args: Parameters<typeof capturedQc.setQueryData>) => {
- if (cancelSpy.mock.calls.length > 0) cancelledBeforeWrite = true
- return originalSetQueryData(...args)
- }) as typeof capturedQc.setQueryData)
-
- await runMutation({ serverIds: ["srv_2", "srv_1"] })
-
- expect(
- cancelSpy.mock.calls.some((c) => {
- const k = c[0]?.queryKey as unknown[] | undefined
- return Array.isArray(k) && k[0] === "community" && k[1] === "servers"
- }),
- ).toBe(true)
- expect(cancelledBeforeWrite).toBe(true)
- })
-
- it("applies the optimistic reorder to the servers cache", async () => {
- capturedQc.setQueryData(communityKeys.servers(), {
- servers: [
- { id: "srv_1", name: "a", initial: "A", active: false, unread: false, mentions: 0 },
- { id: "srv_2", name: "b", initial: "B", active: false, unread: false, mentions: 0 },
- ],
- })
- apiFetchMock.mockResolvedValueOnce(undefined)
- const mod = await load()
- mod.useReorderServers()
- await runMutation({ serverIds: ["srv_2", "srv_1"] })
- const cache = capturedQc.getQueryData<{ servers: { id: string }[] }>(communityKeys.servers())
- expect(cache?.servers.map((s) => s.id)).toEqual(["srv_2", "srv_1"])
- })
-
- it("rolls back to the snapshot on failure", async () => {
- capturedQc.setQueryData(communityKeys.servers(), {
- servers: [
- { id: "srv_1", name: "a", initial: "A", active: false, unread: false, mentions: 0 },
- { id: "srv_2", name: "b", initial: "B", active: false, unread: false, mentions: 0 },
- ],
- })
- apiFetchMock.mockRejectedValueOnce(new Error("boom"))
- const mod = await load()
- mod.useReorderServers()
- await runMutation({ serverIds: ["srv_2", "srv_1"] }).catch(() => {})
- const cache = capturedQc.getQueryData<{ servers: { id: string }[] }>(communityKeys.servers())
- expect(cache?.servers.map((s) => s.id)).toEqual(["srv_1", "srv_2"])
- })
-})
-
describe("useMoveChannel", () => {
it("PATCHes the channel with the new categoryId and invalidates the server tree", async () => {
apiFetchMock.mockResolvedValueOnce(undefined)
diff --git a/src/web/src/hooks/community/mutations/channels.ts b/src/web/src/hooks/community/mutations/channels.ts
index e8b576c4f..8482633d2 100644
--- a/src/web/src/hooks/community/mutations/channels.ts
+++ b/src/web/src/hooks/community/mutations/channels.ts
@@ -320,47 +320,6 @@ export function useDeleteCategory() {
})
}
-// ── Reorders ──────────────────────────────────────────────────────────────
-
-export type ReorderServersArgs = { serverIds: string[] }
-
-/**
- * Optimistically reorder the rail; roll back on failure. The rail's order is
- * pure UX — the WS doesn't broadcast reorders, so the same-tab optimistic
- * write is the only signal cross-tab clients get.
- */
-export function useReorderServers() {
- const queryClient = useQueryClient()
- return useMutation<void, Error, ReorderServersArgs, { snapshot: unknown }>({
- mutationFn: async ({ serverIds }) => {
- await apiFetch("/api/community/servers/reorder", {
- method: "PATCH",
- body: JSON.stringify({ serverIds }),
- })
- },
- onMutate: async (args) => {
- const key = communityKeys.servers()
- await queryClient.cancelQueries({ queryKey: key })
- const snapshot = queryClient.getQueryData(key)
- queryClient.setQueryData(key, (prev: { servers: { id: string }[] } | undefined) => {
- if (!prev) return prev
- const map = new Map(prev.servers.map((s) => [s.id, s]))
- return {
- ...prev,
- servers: args.serverIds
- .map((id) => map.get(id))
- .filter((s): s is NonNullable<typeof s> => Boolean(s)),
- }
- })
- return { snapshot }
- },
- onError: (_err, _args, ctx) => {
- if (ctx?.snapshot) queryClient.setQueryData(communityKeys.servers(), ctx.snapshot)
- },
- onSettled: () => invalidateChannelRefDirectory(queryClient),
- })
-}
-
export type ReorderCategoriesArgs = { serverId: string; categoryIds: string[] }
export function useReorderCategories() {
diff --git a/src/web/src/hooks/community/mutations/folders.test.ts b/src/web/src/hooks/community/mutations/folders.test.ts
deleted file mode 100644
index 9b7156aca..000000000
--- a/src/web/src/hooks/community/mutations/folders.test.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest"
-import { QueryClient } from "@tanstack/react-query"
-import { communityKeys } from "@/lib/query-keys"
-
-vi.mock("react", () => ({
- useRef: (initial: unknown) => ({ current: initial }),
- useCallback: (fn: unknown) => fn,
- useEffect: () => {},
- useState: (initial: unknown) => [initial, () => {}],
-}))
-
-const apiFetchMock = vi.fn()
-vi.mock("@/lib/api/client", () => ({
- apiFetch: (...args: unknown[]) => apiFetchMock(...args),
-}))
-
-type MutConfig<Args, Ctx> = {
- mutationFn?: (args: Args) => unknown
- onMutate?: (args: Args) => Promise<Ctx> | Ctx
- onSuccess?: (data: unknown, args: Args, ctx: Ctx) => unknown
- onError?: (err: unknown, args: Args, ctx: Ctx) => unknown
-}
-let capturedConfig: MutConfig<unknown, unknown> | null = null
-let capturedQc: QueryClient
-vi.mock("@tanstack/react-query", async () => {
- const actual = await vi.importActual<typeof import("@tanstack/react-query")>("@tanstack/react-query")
- return {
- ...actual,
- useQueryClient: () => capturedQc,
- useMutation: (config: MutConfig<unknown, unknown>) => {
- capturedConfig = config
- return {}
- },
- }
-})
-
-async function runMutation<Args>(args: Args) {
- const cfg = capturedConfig as MutConfig<Args, unknown>
- const ctx = cfg.onMutate ? await cfg.onMutate(args) : undefined
- try {
- const data = cfg.mutationFn ? await cfg.mutationFn(args) : undefined
- cfg.onSuccess?.(data, args, ctx)
- return { data, ctx }
- } catch (err) {
- cfg.onError?.(err, args, ctx)
- throw err
- }
-}
-
-async function load() {
- vi.resetModules()
- return await import("./folders")
-}
-
-beforeEach(() => {
- apiFetchMock.mockReset()
- capturedConfig = null
- capturedQc = new QueryClient()
-})
-
-describe("useDeleteServerFolder — rollback", () => {
- it("restores the folder on failure", async () => {
- capturedQc.setQueryData(communityKeys.folders(), {
- folders: [{ id: "fld_1", name: "g", position: 0, servers: [] }],
- })
- apiFetchMock.mockRejectedValueOnce(new Error("boom"))
- const mod = await load()
- mod.useDeleteServerFolder()
- await runMutation({ folderId: "fld_1" }).catch(() => {})
- const cache = capturedQc.getQueryData<{ folders: { id: string }[] }>(communityKeys.folders())
- expect(cache?.folders).toHaveLength(1)
- })
-})
-
-describe("useUpdateFolderItems — rollback", () => {
- it("restores previous membership on failure", async () => {
- capturedQc.setQueryData(communityKeys.folders(), {
- folders: [
- {
- id: "fld_1",
- name: "g",
- position: 0,
- servers: [{ id: "s_1", name: "a", initial: "A", icon: null }],
- },
- ],
- })
- apiFetchMock.mockRejectedValueOnce(new Error("boom"))
- const mod = await load()
- mod.useUpdateFolderItems()
- await runMutation({ folderId: "fld_1", serverIds: ["s_1", "s_2"] }).catch(() => {})
- const cache = capturedQc.getQueryData<{ folders: { servers: { id: string }[] }[] }>(
- communityKeys.folders(),
- )
- expect(cache?.folders[0].servers.map((s) => s.id)).toEqual(["s_1"])
- })
-})
diff --git a/src/web/src/hooks/community/mutations/folders.ts b/src/web/src/hooks/community/mutations/folders.ts
deleted file mode 100644
index 5b383d630..000000000
--- a/src/web/src/hooks/community/mutations/folders.ts
+++ /dev/null
@@ -1,232 +0,0 @@
-"use client"
-
-import { useMutation, useQueryClient } from "@tanstack/react-query"
-import { apiFetch } from "@/lib/api/client"
-import { communityKeys } from "@/lib/query-keys"
-import type { CommunityFolder, FolderServer } from "@/lib/community/models/navigation"
-import type { FoldersResponse } from "@/hooks/community/use-folders"
-import type { ServersResponse } from "@/hooks/community/use-servers"
-
-/**
- * Server-folder mutations mirror the God-context's `createServerFolderWith` /
- * `updateFolderItems` / `deleteServerFolder` / `reorderFolders` — optimistic
- * writes into `communityKeys.folders()`, rollback on failure.
- *
- * The "create folder with two servers" flow is the odd one out because it
- * derives the folder's `servers` from the current `servers` list. That means
- * we need to read the servers cache at call-time to hydrate the temp folder.
- */
-
-// ── Create folder with two servers ─────────────────────────────────────────
-
-export type CreateServerFolderWithArgs = {
- serverIdA: string
- serverIdB: string
-}
-export type CreateServerFolderWithResult = { id: string }
-
-export function useCreateServerFolderWith() {
- const queryClient = useQueryClient()
- return useMutation<
- CreateServerFolderWithResult,
- Error,
- CreateServerFolderWithArgs,
- { snapshot: FoldersResponse | undefined; tempId: string }
- >({
- mutationFn: async ({ serverIdA, serverIdB }) => {
- // Right-click → "Create group" on a single rail server reuses this
- // same mutation with `serverIdA === serverIdB` (see `server-rail.tsx`)
- // to seed a one-server folder the user can then drag more servers
- // into. Dedupe so that path doesn't insert the same server twice —
- // both here and in `onMutate` below.
- const serverIds = [...new Set([serverIdA, serverIdB])]
- return apiFetch<CreateServerFolderWithResult>(
- "/api/community/users/me/server-folders",
- {
- method: "POST",
- body: JSON.stringify({ name: "Group", serverIds }),
- },
- )
- },
- onMutate: async (args) => {
- const key = communityKeys.folders()
- await queryClient.cancelQueries({ queryKey: key })
- const snapshot = queryClient.getQueryData<FoldersResponse>(key)
- const servers = queryClient.getQueryData<ServersResponse>(communityKeys.servers())
- const findServer = (id: string): FolderServer | null => {
- const s = servers?.servers.find((sv) => sv.id === id)
- if (!s) return null
- return { id: s.id, name: s.name, initial: s.initial, icon: s.icon ?? null }
- }
- const tempId = `temp_${Date.now()}`
- const uniqueIds = [...new Set([args.serverIdA, args.serverIdB])]
- const tempFolder: CommunityFolder = {
- id: tempId,
- name: "Group",
- position: snapshot?.folders.length ?? 0,
- servers: uniqueIds.map(findServer).filter((s): s is FolderServer => s !== null),
- }
- queryClient.setQueryData<FoldersResponse | undefined>(key, (prev) =>
- prev
- ? { ...prev, folders: [...prev.folders, tempFolder] }
- : { folders: [tempFolder] },
- )
- return { snapshot, tempId }
- },
- onError: (_err, _args, ctx) => {
- if (!ctx) return
- // If we have a full pre-mutation snapshot, restore it. Otherwise remove
- // just the temp row so we don't obliterate concurrently-updated folders.
- if (ctx.snapshot) {
- queryClient.setQueryData(communityKeys.folders(), ctx.snapshot)
- return
- }
- queryClient.setQueryData<FoldersResponse | undefined>(
- communityKeys.folders(),
- (prev) => (prev ? { ...prev, folders: prev.folders.filter((f) => f.id !== ctx.tempId) } : prev),
- )
- },
- onSuccess: (data, _args, ctx) => {
- if (!ctx) return
- queryClient.setQueryData<FoldersResponse | undefined>(
- communityKeys.folders(),
- (prev) =>
- prev
- ? { ...prev, folders: prev.folders.map((f) => (f.id === ctx.tempId ? { ...f, id: data.id } : f)) }
- : prev,
- )
- },
- })
-}
-
-// ── Update folder items ────────────────────────────────────────────────────
-
-export type UpdateFolderItemsArgs = {
- folderId: string
- serverIds: string[]
-}
-
-export function useUpdateFolderItems() {
- const queryClient = useQueryClient()
- return useMutation<
- void,
- Error,
- UpdateFolderItemsArgs,
- { snapshot: FoldersResponse | undefined }
- >({
- mutationFn: async ({ folderId, serverIds }) => {
- if (serverIds.length === 0) {
- await apiFetch(`/api/community/users/me/server-folders/${folderId}`, { method: "DELETE" })
- return
- }
- await apiFetch(`/api/community/users/me/server-folders/${folderId}`, {
- method: "PATCH",
- body: JSON.stringify({ serverIds }),
- })
- },
- onMutate: async (args) => {
- const key = communityKeys.folders()
- await queryClient.cancelQueries({ queryKey: key })
- const snapshot = queryClient.getQueryData<FoldersResponse>(key)
- const railServers = queryClient.getQueryData<ServersResponse>(communityKeys.servers())
- queryClient.setQueryData<FoldersResponse | undefined>(key, (prev) => {
- if (!prev) return prev
- if (args.serverIds.length === 0) {
- return { ...prev, folders: prev.folders.filter((f) => f.id !== args.folderId) }
- }
- return {
- ...prev,
- folders: prev.folders.map((f) => {
- if (f.id !== args.folderId) return f
- const newServers = args.serverIds.map((id) => {
- const existing = f.servers.find((s) => s.id === id)
- if (existing) return existing
- const fromRail = railServers?.servers.find((s) => s.id === id)
- return fromRail
- ? { id: fromRail.id, name: fromRail.name, initial: fromRail.initial, icon: fromRail.icon ?? null }
- : { id, name: "", initial: "?", icon: null }
- })
- return { ...f, servers: newServers }
- }),
- }
- })
- return { snapshot }
- },
- onError: (_err, _args, ctx) => {
- if (ctx?.snapshot) queryClient.setQueryData(communityKeys.folders(), ctx.snapshot)
- },
- })
-}
-
-// ── Delete folder ─────────────────────────────────────────────────────────
-
-export type DeleteServerFolderArgs = { folderId: string }
-
-export function useDeleteServerFolder() {
- const queryClient = useQueryClient()
- return useMutation<
- void,
- Error,
- DeleteServerFolderArgs,
- { snapshot: FoldersResponse | undefined }
- >({
- mutationFn: async ({ folderId }) => {
- await apiFetch(`/api/community/users/me/server-folders/${folderId}`, { method: "DELETE" })
- },
- onMutate: async (args) => {
- const key = communityKeys.folders()
- await queryClient.cancelQueries({ queryKey: key })
- const snapshot = queryClient.getQueryData<FoldersResponse>(key)
- queryClient.setQueryData<FoldersResponse | undefined>(key, (prev) =>
- prev ? { ...prev, folders: prev.folders.filter((f) => f.id !== args.folderId) } : prev,
- )
- return { snapshot }
- },
- onError: (_err, _args, ctx) => {
- if (ctx?.snapshot) queryClient.setQueryData(communityKeys.folders(), ctx.snapshot)
- },
- })
-}
-
-// ── Reorder folders ────────────────────────────────────────────────────────
-
-export type ReorderFoldersArgs = { folderIds: string[] }
-
-export function useReorderFolders() {
- const queryClient = useQueryClient()
- return useMutation<
- void,
- Error,
- ReorderFoldersArgs,
- { snapshot: FoldersResponse | undefined }
- >({
- mutationFn: async ({ folderIds }) => {
- await apiFetch("/api/community/users/me/server-folders/reorder", {
- method: "PATCH",
- body: JSON.stringify({ folderIds }),
- })
- },
- onMutate: async (args) => {
- const key = communityKeys.folders()
- await queryClient.cancelQueries({ queryKey: key })
- const snapshot = queryClient.getQueryData<FoldersResponse>(key)
- queryClient.setQueryData<FoldersResponse | undefined>(key, (prev) => {
- if (!prev) return prev
- const map = new Map(prev.folders.map((f) => [f.id, f]))
- return {
- ...prev,
- folders: args.folderIds
- .map((id, i) => {
- const f = map.get(id)
- return f ? { ...f, position: i } : null
- })
- .filter((f): f is CommunityFolder => f !== null),
- }
- })
- return { snapshot }
- },
- onError: (_err, _args, ctx) => {
- if (ctx?.snapshot) queryClient.setQueryData(communityKeys.folders(), ctx.snapshot)
- },
- })
-}
diff --git a/src/web/src/hooks/community/mutations/index.ts b/src/web/src/hooks/community/mutations/index.ts
index 045c312b2..e9cd51b9e 100644
--- a/src/web/src/hooks/community/mutations/index.ts
+++ b/src/web/src/hooks/community/mutations/index.ts
@@ -13,6 +13,6 @@ export * from "./channels"
export * from "./forum"
export * from "./uploads"
export * from "./dm"
-export * from "./folders"
+export * from "./server-rail"
export * from "./notifications"
export * from "./profile"
diff --git a/src/web/src/hooks/community/mutations/server-rail.test.ts b/src/web/src/hooks/community/mutations/server-rail.test.ts
new file mode 100644
index 000000000..baad7b5c5
--- /dev/null
+++ b/src/web/src/hooks/community/mutations/server-rail.test.ts
@@ -0,0 +1,106 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { QueryClient } from "@tanstack/react-query"
+import { communityKeys } from "@/lib/query-keys"
+
+const apiFetchMock = vi.fn()
+const useMutationMock = vi.fn()
+let queryClient: QueryClient
+
+vi.mock("@/lib/api/client", () => ({
+ apiFetch: (...args: unknown[]) => apiFetchMock(...args),
+}))
+vi.mock("@tanstack/react-query", async () => {
+ const actual = await vi.importActual<typeof import("@tanstack/react-query")>("@tanstack/react-query")
+ return {
+ ...actual,
+ useQueryClient: () => queryClient,
+ useMutation: (options: unknown) => useMutationMock(options),
+ }
+})
+
+import { useServerRailCommit } from "./server-rail"
+
+const before = {
+ serverOrder: ["a", "b", "c"],
+ folderOrder: ["one"],
+ folders: { one: ["c"] },
+ expanded: [],
+}
+const after = {
+ serverOrder: ["b", "a", "c"],
+ folderOrder: ["one", "temp_1"],
+ folders: { one: ["c"], temp_1: ["a", "b"] },
+ expanded: ["temp_1"],
+}
+const args = {
+ before,
+ after,
+ commands: [{ kind: "create-folder", clientId: "temp_1", name: "Group", serverIds: ["a", "b"] }] as const,
+}
+
+describe("useServerRailCommit", () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ useMutationMock.mockImplementation((options) => options)
+ queryClient.setQueryData(communityKeys.servers(), {
+ servers: ["a", "b", "c"].map((id) => ({
+ id,
+ name: id.toUpperCase(),
+ initial: id.toUpperCase(),
+ active: false,
+ mentions: 0,
+ })),
+ })
+ queryClient.setQueryData(communityKeys.folders(), {
+ folders: [{
+ id: "one",
+ name: "One",
+ position: 0,
+ servers: [{ id: "c", name: "C", initial: "C", icon: null }],
+ }],
+ })
+ })
+
+ it("uses one PATCH with the full command batch", async () => {
+ const options = useServerRailCommit() as any
+ apiFetchMock.mockResolvedValue({ createdFolderIds: {} })
+ await options.mutationFn(args)
+ expect(apiFetchMock).toHaveBeenCalledWith(
+ "/api/community/users/me/server-rail",
+ { method: "PATCH", body: JSON.stringify({ commands: args.commands }) },
+ )
+ })
+
+ it("cancels both caches before one synchronous optimistic projection", async () => {
+ const options = useServerRailCommit() as any
+ const cancel = vi.spyOn(queryClient, "cancelQueries")
+ const context = await options.onMutate(args)
+ expect(cancel).toHaveBeenCalledTimes(2)
+ expect(queryClient.getQueryData<any>(communityKeys.servers()).servers.map((server: any) => server.id))
+ .toEqual(["b", "a", "c"])
+ expect(queryClient.getQueryData<any>(communityKeys.folders()).folders).toMatchObject([
+ { id: "one", position: 0, servers: [{ id: "c" }] },
+ { id: "temp_1", position: 1, servers: [{ id: "a" }, { id: "b" }] },
+ ])
+ expect(context.servers.servers.map((server: any) => server.id)).toEqual(["a", "b", "c"])
+ })
+
+ it("restores both exact snapshots on failure", async () => {
+ const options = useServerRailCommit() as any
+ const context = await options.onMutate(args)
+ options.onError(new Error("failed"), args, context)
+ expect(queryClient.getQueryData(communityKeys.servers())).toEqual(context.servers)
+ expect(queryClient.getQueryData(communityKeys.folders())).toEqual(context.folders)
+ })
+
+ it("reconciles temporary ids and invalidates both caches on settle", async () => {
+ const options = useServerRailCommit() as any
+ await options.onMutate(args)
+ options.onSuccess({ createdFolderIds: { temp_1: "folder_real" } })
+ expect(queryClient.getQueryData<any>(communityKeys.folders()).folders[1].id).toBe("folder_real")
+ const invalidate = vi.spyOn(queryClient, "invalidateQueries").mockResolvedValue(undefined as never)
+ await options.onSettled()
+ expect(invalidate).toHaveBeenCalledTimes(2)
+ })
+})
diff --git a/src/web/src/hooks/community/mutations/server-rail.ts b/src/web/src/hooks/community/mutations/server-rail.ts
new file mode 100644
index 000000000..0ea8575b2
--- /dev/null
+++ b/src/web/src/hooks/community/mutations/server-rail.ts
@@ -0,0 +1,122 @@
+"use client"
+
+import { useMutation, useQueryClient } from "@tanstack/react-query"
+import type { ServerRailCommand, ServerRailCommitResponse } from "@alook/shared"
+import { apiFetch } from "@/lib/api/client"
+import { communityKeys } from "@/lib/query-keys"
+import type { FoldersResponse } from "@/hooks/community/use-folders"
+import type { ServersResponse } from "@/hooks/community/use-servers"
+import type { FolderServer } from "@/lib/community/models/navigation"
+import type { RailState } from "@/lib/community/server-rail-model"
+
+export type ServerRailCommitArgs = {
+ before: RailState
+ after: RailState
+ commands: ServerRailCommand[]
+}
+
+type ServerRailCommitContext = {
+ servers: ServersResponse | undefined
+ folders: FoldersResponse | undefined
+}
+
+function applyOptimisticRail(
+ servers: ServersResponse | undefined,
+ folders: FoldersResponse | undefined,
+ state: RailState,
+): { servers: ServersResponse | undefined; folders: FoldersResponse | undefined } {
+ const serverById = new Map(servers?.servers.map((server) => [server.id, server]) ?? [])
+ const folderServerById = new Map<string, FolderServer>()
+ for (const folder of folders?.folders ?? []) {
+ for (const server of folder.servers) folderServerById.set(server.id, server)
+ }
+ const asFolderServer = (serverId: string): FolderServer => {
+ const existing = folderServerById.get(serverId)
+ if (existing) return existing
+ const server = serverById.get(serverId)
+ return server
+ ? { id: server.id, name: server.name, initial: server.initial, icon: server.icon ?? null }
+ : { id: serverId, name: "", initial: "?", icon: null }
+ }
+ const folderById = new Map(folders?.folders.map((folder) => [folder.id, folder]) ?? [])
+ return {
+ servers: servers
+ ? {
+ ...servers,
+ servers: state.serverOrder
+ .map((serverId) => serverById.get(serverId))
+ .filter((server): server is ServersResponse["servers"][number] => !!server),
+ }
+ : servers,
+ folders: {
+ folders: state.folderOrder.map((folderId, position) => ({
+ id: folderId,
+ name: folderById.get(folderId)?.name ?? "Group",
+ position,
+ servers: (state.folders[folderId] ?? []).map(asFolderServer),
+ })),
+ },
+ }
+}
+
+function reconcileCreatedFolderIds(
+ folders: FoldersResponse | undefined,
+ createdFolderIds: Record<string, string>,
+): FoldersResponse | undefined {
+ if (!folders || Object.keys(createdFolderIds).length === 0) return folders
+ return {
+ ...folders,
+ folders: folders.folders.map((folder) => ({
+ ...folder,
+ id: createdFolderIds[folder.id] ?? folder.id,
+ })),
+ }
+}
+
+export function useServerRailCommit() {
+ const queryClient = useQueryClient()
+ const serversKey = communityKeys.servers()
+ const foldersKey = communityKeys.folders()
+ return useMutation<
+ ServerRailCommitResponse,
+ Error,
+ ServerRailCommitArgs,
+ ServerRailCommitContext
+ >({
+ scope: { id: "server-rail-commit" },
+ mutationFn: ({ commands }) => apiFetch<ServerRailCommitResponse>(
+ "/api/community/users/me/server-rail",
+ { method: "PATCH", body: JSON.stringify({ commands }) },
+ ),
+ onMutate: async ({ after }) => {
+ await Promise.all([
+ queryClient.cancelQueries({ queryKey: serversKey, exact: true }),
+ queryClient.cancelQueries({ queryKey: foldersKey, exact: true }),
+ ])
+ const context: ServerRailCommitContext = {
+ servers: queryClient.getQueryData<ServersResponse>(serversKey),
+ folders: queryClient.getQueryData<FoldersResponse>(foldersKey),
+ }
+ const optimistic = applyOptimisticRail(context.servers, context.folders, after)
+ queryClient.setQueryData(serversKey, optimistic.servers)
+ queryClient.setQueryData(foldersKey, optimistic.folders)
+ return context
+ },
+ onError: (_error, _args, context) => {
+ if (!context) return
+ queryClient.setQueryData(serversKey, context.servers)
+ queryClient.setQueryData(foldersKey, context.folders)
+ },
+ onSuccess: (response) => {
+ queryClient.setQueryData<FoldersResponse | undefined>(foldersKey, (folders) =>
+ reconcileCreatedFolderIds(folders, response.createdFolderIds),
+ )
+ },
+ onSettled: async () => {
+ await Promise.all([
+ queryClient.invalidateQueries({ queryKey: serversKey, exact: true }),
+ queryClient.invalidateQueries({ queryKey: foldersKey, exact: true }),
+ ])
+ },
+ })
+}
diff --git a/src/web/src/lib/community/server-rail-model.ts b/src/web/src/lib/community/server-rail-model.ts
new file mode 100644
index 000000000..375a3d78d
--- /dev/null
+++ b/src/web/src/lib/community/server-rail-model.ts
@@ -0,0 +1,316 @@
+import { MAX_SERVER_RAIL_FOLDERS, type ServerRailCommand } from "@alook/shared"
+
+import type { CommunityFolder } from "@/lib/community/models/navigation"
+
+export type RailEntity =
+ | { kind: "server"; id: string }
+ | { kind: "folder"; id: string }
+
+export type RailOperation = "reorder-before" | "reorder-after" | "combine"
+
+export type RailInstruction = {
+ operation: RailOperation
+ source: RailEntity
+ target: RailEntity
+ newFolderId?: string
+}
+
+export type RailState = {
+ serverOrder: string[]
+ folderOrder: string[]
+ folders: Record<string, string[]>
+ expanded: string[]
+}
+
+export type RailCommitResult =
+ | { applied: true; state: RailState; commands: ServerRailCommand[] }
+ | { applied: false; state: RailState; reason: string }
+
+function unique(values: readonly string[]): string[] {
+ return [...new Set(values)]
+}
+
+function sameArray(left: readonly string[], right: readonly string[]): boolean {
+ return left.length === right.length && left.every((value, index) => value === right[index])
+}
+
+export function railStateFromData(
+ serverIds: readonly string[],
+ folders: readonly CommunityFolder[],
+ expanded: readonly string[],
+): RailState {
+ const membershipIds = new Set(serverIds)
+ const claimedServerIds = new Set<string>()
+ const projectedFolders = [...folders]
+ .sort((left, right) => left.position - right.position
+ || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0))
+ .map((folder) => ({
+ id: folder.id,
+ serverIds: folder.servers
+ .map((server) => server.id)
+ .filter((serverId) => {
+ if (!membershipIds.has(serverId) || claimedServerIds.has(serverId)) return false
+ claimedServerIds.add(serverId)
+ return true
+ }),
+ }))
+ .filter((folder) => folder.serverIds.length > 0)
+ return {
+ serverOrder: [...serverIds],
+ folderOrder: projectedFolders.map((folder) => folder.id),
+ folders: Object.fromEntries(
+ projectedFolders.map((folder) => [folder.id, folder.serverIds]),
+ ),
+ expanded: expanded.filter((folderId) => projectedFolders.some((folder) => folder.id === folderId)),
+ }
+}
+
+export function cloneRailState(state: RailState): RailState {
+ return {
+ serverOrder: [...state.serverOrder],
+ folderOrder: [...state.folderOrder],
+ folders: Object.fromEntries(
+ Object.entries(state.folders).map(([folderId, serverIds]) => [folderId, [...serverIds]]),
+ ),
+ expanded: [...state.expanded],
+ }
+}
+
+export function folderForServer(state: RailState, serverId: string): string | null {
+ for (const folderId of state.folderOrder) {
+ if (state.folders[folderId]?.includes(serverId)) return folderId
+ }
+ return null
+}
+
+export function visibleTopLevelServers(state: RailState): string[] {
+ const claimed = new Set(Object.values(state.folders).flat())
+ return state.serverOrder.filter((serverId) => !claimed.has(serverId))
+}
+
+export function railStateErrors(state: RailState): string[] {
+ const errors: string[] = []
+ const serverIds = new Set(state.serverOrder)
+ if (serverIds.size !== state.serverOrder.length) errors.push("server order contains duplicates")
+ if (new Set(state.folderOrder).size !== state.folderOrder.length) errors.push("folder order contains duplicates")
+ if (state.folderOrder.length > MAX_SERVER_RAIL_FOLDERS) errors.push("folder limit reached")
+ const claimed = new Set<string>()
+ for (const folderId of state.folderOrder) {
+ const items = state.folders[folderId]
+ if (!items) {
+ errors.push(`folder ${folderId} is missing`)
+ continue
+ }
+ if (items.length === 0) errors.push(`folder ${folderId} is empty`)
+ if (new Set(items).size !== items.length) errors.push(`folder ${folderId} contains duplicates`)
+ for (const serverId of items) {
+ if (!state.serverOrder.includes(serverId)) errors.push(`folder ${folderId} contains unknown server`)
+ if (claimed.has(serverId)) errors.push(`server ${serverId} belongs to multiple folders`)
+ claimed.add(serverId)
+ }
+ }
+ for (const folderId of Object.keys(state.folders)) {
+ if (!state.folderOrder.includes(folderId)) errors.push(`folder ${folderId} is unordered`)
+ }
+ return errors
+}
+
+function samePersistedState(left: RailState, right: RailState): boolean {
+ return sameArray(left.serverOrder, right.serverOrder)
+ && sameArray(left.folderOrder, right.folderOrder)
+ && left.folderOrder.every((folderId) =>
+ sameArray(left.folders[folderId] ?? [], right.folders[folderId] ?? []),
+ )
+}
+
+function moveRelative(
+ list: readonly string[],
+ sourceId: string,
+ targetId: string,
+ after: boolean,
+): string[] {
+ const next = list.filter((id) => id !== sourceId)
+ const targetIndex = next.indexOf(targetId)
+ if (targetIndex === -1) return [...list]
+ next.splice(targetIndex + (after ? 1 : 0), 0, sourceId)
+ return next
+}
+
+function removeServerFromFolder(state: RailState, serverId: string): void {
+ const folderId = folderForServer(state, serverId)
+ if (!folderId) return
+ state.folders[folderId] = state.folders[folderId]!.filter((id) => id !== serverId)
+ if (state.folders[folderId]!.length > 0) return
+ delete state.folders[folderId]
+ state.folderOrder = state.folderOrder.filter((id) => id !== folderId)
+ state.expanded = state.expanded.filter((id) => id !== folderId)
+}
+
+function moveServerRelative(
+ state: RailState,
+ sourceId: string,
+ targetId: string,
+ after: boolean,
+): boolean {
+ const sourceFolder = folderForServer(state, sourceId)
+ const targetFolder = folderForServer(state, targetId)
+ if (sourceFolder === targetFolder) {
+ if (sourceFolder) {
+ state.folders[sourceFolder] = moveRelative(
+ state.folders[sourceFolder]!,
+ sourceId,
+ targetId,
+ after,
+ )
+ } else {
+ state.serverOrder = moveRelative(state.serverOrder, sourceId, targetId, after)
+ }
+ return true
+ }
+ removeServerFromFolder(state, sourceId)
+ if (targetFolder) {
+ state.folders[targetFolder] = moveRelative(
+ [...state.folders[targetFolder]!, sourceId],
+ sourceId,
+ targetId,
+ after,
+ )
+ state.expanded = unique([...state.expanded, targetFolder])
+ return true
+ }
+ state.serverOrder = moveRelative(state.serverOrder, sourceId, targetId, after)
+ return true
+}
+
+function applyCombine(state: RailState, instruction: RailInstruction): string | null {
+ if (instruction.source.kind !== "server") return "folders cannot combine"
+ const sourceId = instruction.source.id
+ const sourceFolder = folderForServer(state, sourceId)
+ if (instruction.target.kind === "folder") {
+ const targetItems = state.folders[instruction.target.id]
+ if (!targetItems) return "target folder is missing"
+ if (sourceFolder === instruction.target.id) return "server is already in target folder"
+ removeServerFromFolder(state, sourceId)
+ state.folders[instruction.target.id] = [...targetItems, sourceId]
+ state.expanded = unique([...state.expanded, instruction.target.id])
+ return null
+ }
+
+ const targetId = instruction.target.id
+ const targetFolder = folderForServer(state, targetId)
+ if (targetFolder) {
+ if (sourceFolder === targetFolder) return "servers already share a folder"
+ removeServerFromFolder(state, sourceId)
+ const targetItems = state.folders[targetFolder]!
+ const targetIndex = targetItems.indexOf(targetId)
+ state.folders[targetFolder] = [...targetItems]
+ state.folders[targetFolder]!.splice(targetIndex + 1, 0, sourceId)
+ state.expanded = unique([...state.expanded, targetFolder])
+ return null
+ }
+ if (sourceFolder) return "creating a folder requires two top-level servers"
+ if (state.folderOrder.length >= MAX_SERVER_RAIL_FOLDERS) return "folder limit reached"
+ if (!instruction.newFolderId || state.folders[instruction.newFolderId]) {
+ return "new folder id is required"
+ }
+ state.folderOrder.push(instruction.newFolderId)
+ state.folders[instruction.newFolderId] = [sourceId, targetId]
+ state.expanded = unique([...state.expanded, instruction.newFolderId])
+ return null
+}
+
+export function planRailPersistence(before: RailState, after: RailState): ServerRailCommand[] {
+ if (samePersistedState(before, after)) return []
+ const commands: ServerRailCommand[] = []
+ if (!sameArray(before.serverOrder, after.serverOrder)) {
+ commands.push({ kind: "reorder-servers", serverIds: [...after.serverOrder] })
+ }
+ const added = after.folderOrder.filter((folderId) => !before.folderOrder.includes(folderId))
+ for (const folderId of before.folderOrder) {
+ const afterItems = after.folders[folderId]
+ if (!afterItems) commands.push({ kind: "delete-folder", folderId })
+ else if (!sameArray(before.folders[folderId] ?? [], afterItems)) {
+ commands.push({ kind: "replace-folder-items", folderId, serverIds: [...afterItems] })
+ }
+ }
+ if (added.length === 1) {
+ const clientId = added[0]!
+ commands.push({
+ kind: "create-folder",
+ clientId,
+ name: "Group",
+ serverIds: [...after.folders[clientId]!],
+ })
+ }
+ const sameFolderSet = before.folderOrder.length === after.folderOrder.length
+ && before.folderOrder.every((folderId) => after.folderOrder.includes(folderId))
+ if (sameFolderSet && !sameArray(before.folderOrder, after.folderOrder)) {
+ commands.push({ kind: "reorder-folders", folderIds: [...after.folderOrder] })
+ }
+ return commands
+}
+
+export function commitRailInstruction(
+ before: RailState,
+ instruction: RailInstruction,
+): RailCommitResult {
+ if (railStateErrors(before).length > 0) {
+ return { applied: false, state: before, reason: "invalid start state" }
+ }
+ if (
+ instruction.source.kind === instruction.target.kind
+ && instruction.source.id === instruction.target.id
+ ) {
+ return { applied: false, state: before, reason: "source equals target" }
+ }
+ const next = cloneRailState(before)
+ let error: string | null = null
+ if (instruction.operation === "combine") {
+ error = applyCombine(next, instruction)
+ } else if (instruction.source.kind === "folder" || instruction.target.kind === "folder") {
+ if (instruction.source.kind !== "folder" || instruction.target.kind !== "folder") {
+ error = "server and folder orders cannot interleave"
+ } else if (!next.folderOrder.includes(instruction.source.id)
+ || !next.folderOrder.includes(instruction.target.id)) {
+ error = "folder is missing"
+ } else {
+ next.folderOrder = moveRelative(
+ next.folderOrder,
+ instruction.source.id,
+ instruction.target.id,
+ instruction.operation === "reorder-after",
+ )
+ }
+ } else if (!next.serverOrder.includes(instruction.source.id)
+ || !next.serverOrder.includes(instruction.target.id)) {
+ error = "server is missing"
+ } else {
+ moveServerRelative(
+ next,
+ instruction.source.id,
+ instruction.target.id,
+ instruction.operation === "reorder-after",
+ )
+ }
+ if (error) return { applied: false, state: before, reason: error }
+ const stateError = railStateErrors(next)[0]
+ if (stateError) return { applied: false, state: before, reason: stateError }
+ const commands = planRailPersistence(before, next)
+ if (commands.length === 0) return { applied: false, state: before, reason: "instruction is a no-op" }
+ if (commands.length > 3) return { applied: false, state: before, reason: "instruction exceeds command budget" }
+ return { applied: true, state: next, commands }
+}
+
+export function railMoveAnnouncement(
+ instruction: RailInstruction,
+ names: { servers: ReadonlyMap<string, string>; folders: ReadonlyMap<string, string> },
+): string {
+ const source = instruction.source.kind === "server"
+ ? names.servers.get(instruction.source.id) ?? "Server"
+ : names.folders.get(instruction.source.id) ?? "Group"
+ const target = instruction.target.kind === "server"
+ ? names.servers.get(instruction.target.id) ?? "server"
+ : names.folders.get(instruction.target.id) ?? "group"
+ if (instruction.operation === "combine") return `${source} moved into ${target}`
+ return `${source} moved ${instruction.operation === "reorder-before" ? "before" : "after"} ${target}`
+}
diff --git a/src/web/src/lib/community/testids.ts b/src/web/src/lib/community/testids.ts
index a79dd18e3..b542427de 100644
--- a/src/web/src/lib/community/testids.ts
+++ b/src/web/src/lib/community/testids.ts
@@ -15,6 +15,12 @@ export const tid = {
wsRetry: "community-ws-retry",
serverAdd: "community-server-add",
serverRailScroll: "community-server-rail-scroll",
+ serverRailFolder: (id: string) => `community-server-folder-${id}`,
+ serverRailInsert: (id: string) => `community-server-rail-insert-${id}`,
+ serverRailInsertFolder: (id: string) => `community-server-rail-insert-folder-${id}`,
+ serverRailMoveDestination: "community-server-rail-move-destination",
+ serverRailMoveTarget: "community-server-rail-move-target",
+ serverRailMoveConfirm: "community-server-rail-move-confirm",
channelSidebarScroll: "community-channel-sidebar-scroll",
channelSidebarPending: (serverId: string) => `community-channel-sidebar-pending-${serverId}`,
createServerSubmit: "community-create-server-submit",
diff --git a/src/web/src/test/e2e-ui/37-server-rail-pdd.spec.ts b/src/web/src/test/e2e-ui/37-server-rail-pdd.spec.ts
new file mode 100644
index 000000000..a1c543888
--- /dev/null
+++ b/src/web/src/test/e2e-ui/37-server-rail-pdd.spec.ts
@@ -0,0 +1,134 @@
+import type { Page } from "@playwright/test"
+import { expect, test } from "./_fixtures/community-fixture"
+import { seedChannel, seedServer } from "./_fixtures/seed"
+import { tid } from "./_fixtures/testids"
+
+const RAIL_ENDPOINT = "/api/community/users/me/server-rail"
+
+async function openMove(page: Page, serverId: string) {
+ const icon = page.getByTestId(tid.serverIcon(serverId))
+ await icon.focus()
+ await expect(icon.locator("xpath=ancestor::*[@data-slot='context-menu-trigger'][1]")).toBeVisible()
+ await icon.click({ button: "right" })
+ await page.getByRole("menuitem", { name: "Move…" }).click()
+ await expect(page.getByRole("heading", { name: "Move server" })).toBeVisible()
+}
+
+test("server rail commits one PDD drop and exposes mobile Move parity", async ({ asUser }) => {
+ test.setTimeout(150_000)
+ const stamp = Date.now()
+ const first = await seedServer("alice", `Rail first ${stamp}`)
+ const second = await seedServer("alice", `Rail second ${stamp}`)
+ const third = await seedServer("alice", `Rail third ${stamp}`)
+ const channel = await seedChannel("alice", first, `rail-${stamp}`)
+ const { page } = await asUser("alice")
+ await page.setViewportSize({ width: 1280, height: 900 })
+ await page.goto(`/c/channels/${first}/${channel}`)
+ await expect(page.getByTestId(tid.serverIcon(first))).toBeVisible({ timeout: 30_000 })
+
+ const railRequests: Array<{ body: unknown; status?: number }> = []
+ page.on("request", (request) => {
+ if (request.method() !== "PATCH" || new URL(request.url()).pathname !== RAIL_ENDPOINT) return
+ railRequests.push({ body: request.postDataJSON() })
+ })
+ page.on("response", (response) => {
+ if (response.request().method() !== "PATCH" || new URL(response.url()).pathname !== RAIL_ENDPOINT) return
+ const current = railRequests.at(-1)
+ if (current) current.status = response.status()
+ })
+
+ const source = page.getByTestId(tid.serverIcon(first))
+ const target = page.getByTestId(tid.serverIcon(second))
+ await source.focus()
+ await expect(source.locator("xpath=ancestor::*[@data-slot='context-menu-trigger'][1]")).toBeVisible()
+ await target.focus()
+ await expect(target.locator("xpath=ancestor::*[@data-slot='context-menu-trigger'][1]")).toBeVisible()
+ await page.evaluate(() => {
+ const events: string[] = []
+ Reflect.set(window, "__railDragEvents", events)
+ for (const type of ["dragstart", "dragenter", "dragover", "drop", "dragend"]) {
+ document.addEventListener(type, () => events.push(type), { capture: true })
+ }
+ })
+ const sourceDraggable = source.locator("xpath=ancestor::*[@draggable='true'][1]")
+ const targetDraggable = target.locator("xpath=ancestor::*[@draggable='true'][1]")
+ await expect(sourceDraggable).toHaveCount(1)
+ await expect(targetDraggable).toHaveCount(1)
+ await sourceDraggable.dragTo(targetDraggable, {
+ targetPosition: { x: 28, y: 34 },
+ force: true,
+ })
+ await page.waitForTimeout(500)
+ const dragEvents = await page.evaluate(() => Reflect.get(window, "__railDragEvents"))
+ expect(dragEvents).toContain("dragstart")
+ expect(dragEvents).toContain("drop")
+ await expect.poll(() => railRequests.length, { timeout: 10_000 }).toBe(1)
+ expect(railRequests).toHaveLength(1)
+ expect(railRequests[0]?.body).toMatchObject({
+ commands: [{ kind: "reorder-servers" }],
+ })
+ await expect.poll(() => railRequests[0]?.status).toBe(200)
+
+ await page.setViewportSize({ width: 390, height: 844 })
+ await page.getByRole("button", { name: "Back" }).click()
+ await expect.poll(() => new URL(page.url()).pathname).toBe(`/c/channels/${first}`)
+ await openMove(page, third)
+ await page.getByTestId(tid.serverRailMoveDestination).selectOption("new")
+ await page.getByTestId(tid.serverRailMoveTarget).selectOption(first)
+ const createResponsePromise = page.waitForResponse((response) =>
+ response.request().method() === "PATCH" && new URL(response.url()).pathname === RAIL_ENDPOINT,
+ )
+ await page.getByTestId(tid.serverRailMoveConfirm).click()
+ const createResponse = await createResponsePromise
+ expect(createResponse.status()).toBe(200)
+ expect(railRequests).toHaveLength(2)
+ expect(railRequests[1]?.body).toMatchObject({
+ commands: [{ kind: "create-folder", name: "Group", serverIds: [third, first] }],
+ })
+ await expect(page.getByTestId(tid.serverIcon(third))).toBeVisible()
+ await expect(page.getByTestId(tid.serverIcon(first))).toBeVisible()
+ await expect(page.getByTestId(tid.serverIcon(second))).toBeVisible()
+ const rail = page.getByTestId(tid.serverRailScroll)
+ const beforeSwipe = await rail.evaluate((element) => element.scrollTop)
+ const box = await page.getByTestId(tid.serverIcon(second)).boundingBox()
+ expect(box).not.toBeNull()
+ await page.mouse.move(box!.x + 20, box!.y + 20)
+ await page.mouse.down()
+ await page.mouse.move(box!.x + 20, Math.max(10, box!.y - 100), { steps: 8 })
+ await page.mouse.up()
+ expect(railRequests).toHaveLength(2)
+ expect(await rail.evaluate((element) => element.scrollTop)).toBeGreaterThanOrEqual(beforeSwipe)
+
+ await page.setViewportSize({ width: 1280, height: 900 })
+ let releaseCommit!: () => void
+ const commitGate = new Promise<void>((resolve) => { releaseCommit = resolve })
+ let delayed = false
+ await page.route(`**${RAIL_ENDPOINT}`, async (route) => {
+ if (route.request().method() === "PATCH" && !delayed) {
+ delayed = true
+ await commitGate
+ }
+ await route.continue()
+ })
+ const pendingResponse = page.waitForResponse((response) =>
+ response.request().method() === "PATCH" && new URL(response.url()).pathname === RAIL_ENDPOINT,
+ )
+ try {
+ const topLevel = page.getByTestId(tid.serverIcon(second))
+ await topLevel.focus()
+ await expect(topLevel.locator("xpath=ancestor::*[@data-slot='context-menu-trigger'][1]")).toBeVisible()
+ await topLevel.click({ button: "right" })
+ await page.getByRole("menuitem", { name: "Create group" }).click()
+ await expect.poll(() => railRequests.length).toBe(3)
+
+ const existingFolder = page.locator(`[data-testid^="${tid.serverRailFolder("")}"]`).first()
+ await existingFolder.click({ button: "right" })
+ await page.getByRole("menuitem", { name: "Ungroup" }).click()
+ await page.waitForTimeout(250)
+ expect(railRequests).toHaveLength(3)
+ } finally {
+ releaseCommit()
+ }
+ expect((await pendingResponse).status()).toBe(200)
+ await page.unroute(`**${RAIL_ENDPOINT}`)
+})