Compare commits

..
Author SHA1 Message Date
Lotus CIandClaude Opus 5.5 d5b0b40b17 chore(build): ship only the DTLN files that can load (-9 MB) (#210)
CI / Build & Quality Checks (push) Skipped
CI / Secret scan (gitleaks) (push) Skipped
CI / Playwright smoke (e2e) (push) Skipped
CI / Secret scan (gitleaks) (pull_request) Successful in 24s
CI / Build & Quality Checks (pull_request) Successful in 3m2s
CI / Trigger Desktop Build (pull_request) Skipped
CI / Docker image build & smoke test (pull_request) Skipped
CI / Playwright smoke (e2e) (pull_request) Successful in 30m35s
The DTLN noise-suppression package was copied whole into every build
(57 MB). Its threaded LiteRT build is only used on a cross-origin-isolated
page, and neither the web nor the desktop call page is (no COOP/COEP), so
its ~9 MB could never load; source maps and .d.ts files aren't needed at
runtime either. Leave those out: 57 -> 48 MB per web deploy and desktop
installer. Verified on the built output, not isolated: the DTLN worklet
reaches ready and runs a 300-frame benchmark, no 404s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5
2026-10-25 20:17:20 -04:00
10 changed files with 75 additions and 279 deletions

No files matched your search

-58
View File
@@ -415,64 +415,6 @@ test.describe('local homeserver regression', () => {
.toBe(status);
});
test('status: applies at once, quick changes fold into one write (slow-save report)', async ({
page,
}) => {
let lastOk = 0;
const sent: string[] = [];
await page.route(/\/presence\/[^/]+\/status/, (route) => {
if (route.request().method() !== 'PUT') return route.continue();
const now = Date.now();
if (now - lastOk < 10_000) {
return route.fulfill({
status: 429,
contentType: 'application/json',
body: JSON.stringify({
errcode: 'M_LIMIT_EXCEEDED',
retry_after_ms: 10_000 - (now - lastOk),
}),
});
}
lastOk = now;
sent.push(JSON.parse(route.request().postData() ?? '{}').status_msg ?? '');
return route.continue();
});
await loginUI(page, alice);
await page.getByRole('button', { name: 'User Settings' }).click();
await page.getByText('Account', { exact: true }).first().click();
const input = page.getByLabel('Status message');
const save = input.locator('xpath=ancestor::form[1]').getByRole('button', { name: 'Save' });
// Use up the 10 s budget, then pick three quick statuses in a row.
await input.fill(uniq('first '));
await save.click();
await expect(save).toBeDisabled(); // applied: nothing left to save, no spinner wait
const quick = page.getByRole('group', { name: 'Quick statuses' });
await quick.getByRole('button', { name: /Lunch/ }).click();
await quick.getByRole('button', { name: /Watching/ }).click();
await quick.getByRole('button', { name: /AFK/ }).click();
await expect(input).toHaveValue('😴 AFK');
await expect(save).toBeDisabled();
await expect(page.getByText(/Status set\. Sharing it with others/)).toBeVisible();
await expect
.poll(
async () =>
(
await api<{ status_msg?: string }>(
'GET',
`/_matrix/client/v3/presence/${enc(alice.userId)}/status`,
alice.token,
)
).status_msg,
{ timeout: 30_000 },
)
.toBe('😴 AFK');
// The middle choices were superseded while waiting, never sent.
expect(sent.filter((m) => /Lunch|Watching/.test(m))).toEqual([]);
await expect(page.getByText(/Status set\. Sharing it with others/)).toHaveCount(0);
});
test('touch: long-press opens the message action sheet (#166)', async ({ browser }) => {
const ctx = await browser.newContext({ ...devices['Pixel 7'] });
const page = await ctx.newPage();
+22 -24
View File
@@ -38,7 +38,11 @@ import { SettingTile } from '../../../components/setting-tile';
import { useMatrixClient } from '../../../hooks/useMatrixClient';
import { getAccountData, setAccountData } from '../../../utils/accountData';
import { presenceStateFromSetting } from '../../../hooks/usePresenceUpdater';
import { describePresenceError, queuePresenceWrite } from '../../../utils/presenceWrite';
import {
describePresenceError,
setPresenceWithRetry,
writePresence,
} from '../../../utils/presenceWrite';
import { useSetting } from '../../../state/hooks/settings';
import { settingsAtom } from '../../../state/settings';
import { UserProfile, useUserProfile } from '../../../hooks/useUserProfile';
@@ -415,10 +419,6 @@ function ProfileStatus() {
// until our own echo lands or a short window elapses (bounded so a genuinely
// dropped echo can't block real cross-device updates forever).
const pendingAppliedRef = useRef<{ value: string; ts: number } | null>(null);
// The status as this device last applied or synced it. "Save" compares with
// this, not with the server echo, so it switches off the moment a status is
// applied instead of staying lit until the (rate-limited) write lands.
const [savedMsg, setSavedMsg] = useState<string>(initialStatus);
const [clearAfter, setClearAfter] = useState('0');
const [emojiAnchor, setEmojiAnchor] = useState<RectCords>();
const { presets, addPreset, removePreset } = useStatusPresets();
@@ -442,7 +442,7 @@ function ProfileStatus() {
if (pending) {
if (remoteStatus === pending.value) {
pendingAppliedRef.current = null; // our own echo landed — accept it
} else if (Date.now() - pending.ts < 30_000) {
} else if (Date.now() - pending.ts < 15_000) {
return; // stale echo of the previous status; ignore within the window
} else {
pendingAppliedRef.current = null; // window elapsed — accept external changes
@@ -451,7 +451,6 @@ function ProfileStatus() {
// [Gitea #283] "dnd" is the Do Not Disturb sentinel, not something the user
// typed: don't show it in the status field or keep it as their status.
if (remoteStatus === DND_STATUS_SENTINEL) return;
setSavedMsg(remoteStatus);
if (remoteStatus) {
setStatusMsg(remoteStatus);
localStorage.setItem(STATUS_MSG_KEY(userId), remoteStatus);
@@ -468,10 +467,9 @@ function ProfileStatus() {
useCallback(
(msg: string) =>
// Synapse allows ONE presence write per 10 s per user (shared by all
// devices) and our heartbeat spends that budget too. The shared queue
// waits out a 429 and folds quick successive changes into one write;
// the UI doesn't wait on it (the status is applied locally at once).
queuePresenceWrite(mx, {
// devices) and our heartbeat spends that budget too — wait out a 429
// instead of failing the user's save.
setPresenceWithRetry(mx, {
// Derive presence from the user's chosen setting so writing a status
// never overrides Invisible/DND/Idle (e.g. outing an Invisible user).
presence: presenceStateFromSetting(presenceStatus, hidePresence),
@@ -500,7 +498,6 @@ function ProfileStatus() {
(rawMsg: string, clearAfterValue: string) => {
statusDirtyRef.current = false;
const msg = rawMsg.trim();
setSavedMsg(msg);
// Guard against a stale presence echo reverting this value (see the sync effect).
pendingAppliedRef.current = { value: msg, ts: Date.now() };
noteLocalStatusWrite();
@@ -530,17 +527,19 @@ function ProfileStatus() {
const handleSubmit: FormEventHandler<HTMLFormElement> = (evt) => {
evt.preventDefault();
if (saving) return;
applyStatus(statusMsg, clearAfter);
};
// Preset click = one-click apply: reflect it in the inputs and save immediately.
const applyPreset = useCallback(
(preset: StatusPreset) => {
if (saving) return;
setStatusMsg(preset.label);
setClearAfter(preset.clearAfter);
applyStatus(preset.label, preset.clearAfter);
},
[applyStatus],
[saving, applyStatus],
);
const handleSaveCurrent = useCallback(() => {
@@ -561,18 +560,17 @@ function ProfileStatus() {
pendingAppliedRef.current = { value: '', ts: Date.now() };
noteLocalStatusWrite();
setStatusMsg('');
setSavedMsg('');
localStorage.removeItem(STATUS_MSG_KEY(userId));
localStorage.removeItem(STATUS_EXPIRY_KEY(userId));
writeStatusExpiry(mx, '').catch(() => undefined);
// Preserve the user's chosen presence when clearing the status message.
queuePresenceWrite(mx, {
writePresence(mx, {
presence: presenceStateFromSetting(presenceStatus, hidePresence),
status_msg: '',
}).catch(() => undefined);
};
const hasChanges = statusMsg.trim() !== savedMsg;
const hasChanges = statusMsg !== (presence?.status ?? '');
return (
<SettingTile
@@ -601,6 +599,7 @@ function ProfileStatus() {
variant="Secondary"
fill="Soft"
radii="Pill"
disabled={saving}
onClick={() => applyPreset(preset)}
>
<Text as="span" size="B300">
@@ -626,6 +625,7 @@ function ProfileStatus() {
variant="Secondary"
fill="Soft"
radii="Pill"
disabled={saving}
onClick={() => applyPreset(preset)}
>
<Text as="span" size="B300">
@@ -651,7 +651,7 @@ function ProfileStatus() {
fill="Soft"
radii="Pill"
outlined
disabled={!statusMsg.trim()}
disabled={saving || !statusMsg.trim()}
onClick={handleSaveCurrent}
before={<Icon size="100" src={Icons.Plus} />}
>
@@ -662,7 +662,7 @@ function ProfileStatus() {
</Box>
</Box>
<Box as="form" onSubmit={handleSubmit} gap="200" alignItems="Center">
<Box as="form" onSubmit={handleSubmit} gap="200" alignItems="Center" aria-disabled={saving}>
<Box grow="Yes" direction="Column" gap="100">
<Input
name="statusMsgInput"
@@ -672,6 +672,7 @@ function ProfileStatus() {
placeholder="What's on your mind?"
variant="Secondary"
radii="300"
readOnly={saving}
maxLength={64}
/>
<Text
@@ -732,17 +733,13 @@ function ProfileStatus() {
fill={hasChanges ? 'Solid' : 'Soft'}
outlined
radii="300"
disabled={!hasChanges}
disabled={!hasChanges || saving}
type="submit"
>
{saving && <Spinner variant="Success" fill="Solid" size="300" />}
<Text size="B400">Save</Text>
</Button>
</Box>
{saving && (
<Text size="T200" priority="300" role="status">
Status set. Sharing it with others, this can take a few seconds.
</Text>
)}
{saveState.status === AsyncStatus.Error && (
<Text size="T200" style={{ color: color.Critical.Main }}>
{describePresenceError(saveState.error)}
@@ -767,6 +764,7 @@ function ProfileStatus() {
radii="300"
type="button"
onClick={handleClear}
disabled={saving}
>
<Text size="B300">Clear Status</Text>
</Button>
+2 -19
View File
@@ -1,6 +1,6 @@
import { useEffect, useRef } from 'react';
import { SetPresence } from 'matrix-js-sdk';
import { PresenceDeduper, PresenceWrite, queuePresenceWrite } from '../utils/presenceWrite';
import { PresenceDeduper, PresenceWrite, writePresence } from '../utils/presenceWrite';
import { useMatrixClient } from './useMatrixClient';
import { getLastLocalStatusWrite, pickHeartbeatStatus } from '../utils/ownStatusSync';
import { useSetting } from '../state/hooks/settings';
@@ -70,25 +70,9 @@ export function usePresenceUpdater() {
// by all devices) and /sync already keeps us online — only send when the
// state or status actually changes, so a manual status save isn't 429'd
// by a heartbeat that changed nothing.
// What the server reported in the last resolveStatus() (consumed by send).
let serverNow: { presence: string; status_msg?: string } | undefined;
const send = (write: PresenceWrite, label: string) => {
const server = serverNow;
serverNow = undefined;
if (!deduper.shouldSend(write)) return Promise.resolve();
// The server already shows exactly this (e.g. /sync keeps us online and
// the status is unchanged): writing it again would only spend the
// 10-second budget a status save may need next.
if (
server &&
server.presence === write.presence &&
(server.status_msg ?? '') === (write.status_msg ?? '')
) {
deduper.sent(write);
return Promise.resolve();
}
// Shared queue with the status save: waits out a 429, newest write wins.
return queuePresenceWrite(mx, write)
return writePresence(mx, write)
.then(() => deduper.sent(write))
.catch((err) => warnPresenceFailure(label, err));
};
@@ -100,7 +84,6 @@ export function usePresenceUpdater() {
const local = readStatus();
if (!userId) return local;
const server = await mx.getPresence(userId).catch(() => undefined);
serverNow = server;
const status = pickHeartbeatStatus({
local,
server,
+2 -48
View File
@@ -1,13 +1,7 @@
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { IPresenceOpts, MatrixError } from 'matrix-js-sdk';
import {
PresenceDeduper,
describePresenceError,
isPresenceWritePending,
queuePresenceWrite,
setPresenceWithRetry,
} from './presenceWrite';
import { MatrixError } from 'matrix-js-sdk';
import { PresenceDeduper, describePresenceError, setPresenceWithRetry } from './presenceWrite';
const limited = (retryMs = 3000) =>
new MatrixError(
@@ -85,43 +79,3 @@ test('error wording', () => {
);
assert.match(describePresenceError(new TypeError('Failed to fetch')), /couldn't reach/);
});
test('[status save] queuePresenceWrite: newest wins, waits out 429 once, all callers settle', async () => {
const sent: string[] = [];
let calls = 0;
const sleeps: number[] = [];
const mx = {
setPresence: async (w: IPresenceOpts) => {
calls += 1;
if (calls === 1) {
sent.push(`429:${w.status_msg}`);
throw new MatrixError({ errcode: 'M_LIMIT_EXCEEDED', retry_after_ms: 7000 }, 429);
}
sent.push(`ok:${w.status_msg}`);
},
};
const sleepFn = async (ms: number) => {
sleeps.push(ms);
};
// 'a' goes out at once; 'b' and 'c' arrive while it waits out the limit.
const first = queuePresenceWrite(mx, { presence: 'online', status_msg: 'a' }, { sleepFn });
const second = queuePresenceWrite(mx, { presence: 'online', status_msg: 'b' }, { sleepFn });
const third = queuePresenceWrite(mx, { presence: 'online', status_msg: 'c' }, { sleepFn });
assert.equal(isPresenceWritePending(mx), true);
await Promise.all([first, second, third]);
// 'a' was 429'd; after the wait only the newest ('c') goes out — 'a' isn't
// retried and 'b' is never sent.
assert.deepEqual(sent, ['429:a', 'ok:c']);
assert.deepEqual(sleeps, [7000]);
assert.equal(isPresenceWritePending(mx), false);
});
test('[status save] queuePresenceWrite: a failure rejects the callers of that write', async () => {
const mx = {
setPresence: async () => {
throw new MatrixError({ errcode: 'M_FORBIDDEN' }, 403);
},
};
await assert.rejects(queuePresenceWrite(mx, { presence: 'online', status_msg: 'x' }));
assert.equal(isPresenceWritePending(mx), false);
});
-75
View File
@@ -94,78 +94,3 @@ export const describePresenceError = (e: unknown): string => {
}
return "Failed to save status — couldn't reach the server. Try again.";
};
type PresenceQueue = {
pending?: PresenceWrite;
waiters: { resolve: () => void; reject: (e: unknown) => void }[];
running: boolean;
};
const queues = new WeakMap<object, PresenceQueue>();
/**
* One presence writer per client, newest write wins. The status save and the
* heartbeat share Synapse's one-write-per-10-s budget, so instead of each
* waiting out 429s on its own (and racing), writes queue here: anything still
* waiting is replaced by the newer write, which goes out as soon as the server
* allows. Each caller's promise settles with the outcome of the write that
* finally carried (or superseded) theirs.
*/
export function queuePresenceWrite(
mx: Pick<MatrixClient, 'setPresence'>,
write: PresenceWrite,
opts: { maxWaitMs?: number; sleepFn?: (ms: number) => Promise<void> } = {},
): Promise<void> {
let q = queues.get(mx);
if (!q) {
q = { waiters: [], running: false };
queues.set(mx, q);
}
const queue = q;
queue.pending = write;
const settled = new Promise<void>((resolve, reject) => {
queue.waiters.push({ resolve, reject });
});
if (!queue.running) {
queue.running = true;
const maxWaitMs = opts.maxWaitMs ?? 25_000;
const sleepFn = opts.sleepFn ?? sleep;
(async () => {
let waited = 0;
while (queue.pending) {
const next = queue.pending;
queue.pending = undefined;
const waiters = queue.waiters.splice(0);
try {
// eslint-disable-next-line no-await-in-loop
await writePresence(mx, next);
waited = 0;
if (queue.pending) queue.waiters.unshift(...waiters);
else waiters.forEach((w) => w.resolve());
} catch (e) {
const wait =
e instanceof MatrixError && e.httpStatus === 429
? Math.min(e.getRetryAfterMs() ?? 10_500, 15_000)
: undefined;
if (wait !== undefined && waited + wait <= maxWaitMs) {
waited += wait;
// eslint-disable-next-line no-await-in-loop
await sleepFn(wait);
// After the wait, send whatever is newest: a change made meanwhile
// replaces this one rather than queueing behind it.
queue.pending ??= next;
queue.waiters.unshift(...waiters);
} else if (queue.pending) {
queue.waiters.unshift(...waiters);
} else {
waiters.forEach((w) => w.reject(e));
}
}
}
queue.running = false;
})();
}
return settled;
}
/** Whether a presence write is queued or in flight for this client. */
export const isPresenceWritePending = (mx: object): boolean => queues.get(mx)?.running ?? false;
+1 -1
View File
@@ -87,7 +87,7 @@ export const initClient = async (session: Session): Promise<MatrixClient> => {
// the user (KeyUploadBanner) instead of retrying silently forever.
fetchFn: watchKeyUploads((input, init) => globalThis.fetch(input, init)),
timelineSupport: true,
cryptoCallbacks,
cryptoCallbacks: cryptoCallbacks as any,
// SAS (emoji) + QR-code verification (show/scan/reciprocate).
verificationMethods: ['m.sas.v1', 'm.qr_code.show.v1', 'm.qr_code.scan.v1', 'm.reciprocate.v1'],
oauthClientId: oidcIdentity?.oidc.clientId,
+37
View File
@@ -0,0 +1,37 @@
const secretStorageKeys = new Map();
export function storePrivateKey(keyId, privateKey) {
if (privateKey instanceof Uint8Array === false) {
throw new Error('Unable to store, privateKey is invalid.');
}
secretStorageKeys.set(keyId, privateKey);
}
function hasPrivateKey(keyId) {
return secretStorageKeys.get(keyId) instanceof Uint8Array;
}
function getPrivateKey(keyId) {
return secretStorageKeys.get(keyId);
}
export function clearSecretStorageKeys() {
secretStorageKeys.clear();
}
async function getSecretStorageKey({ keys }) {
const keyIds = Object.keys(keys);
const keyId = keyIds.find(hasPrivateKey);
if (!keyId) return undefined;
const privateKey = getPrivateKey(keyId);
return [keyId, privateKey];
}
function cacheSecretStorageKey(keyId, keyInfo, privateKey) {
secretStorageKeys.set(keyId, privateKey);
}
export const cryptoCallbacks = {
getSecretStorageKey,
cacheSecretStorageKey,
};
-26
View File
@@ -1,26 +0,0 @@
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { clearSecretStorageKeys, cryptoCallbacks, storePrivateKey } from './secretStorageKeys';
const ask = (...ids: string[]) =>
cryptoCallbacks.getSecretStorageKey!(
{ keys: Object.fromEntries(ids.map((id) => [id, {} as never])) },
'm.cross_signing.master',
);
test('[#210] secret storage key cache: null when unknown, key when stored, copies input', async () => {
clearSecretStorageKeys();
assert.equal(await ask('k1'), null);
const key = new Uint8Array([1, 2, 3]);
storePrivateKey('k1', key);
key[0] = 9; // the cache keeps its own copy
assert.deepEqual(await ask('k0', 'k1'), ['k1', new Uint8Array([1, 2, 3])]);
cryptoCallbacks.cacheSecretStorageKey!('k2', {} as never, new Uint8Array([7]));
assert.deepEqual(await ask('k2'), ['k2', new Uint8Array([7])]);
clearSecretStorageKeys();
assert.equal(await ask('k1', 'k2'), null);
assert.throws(() => storePrivateKey('k3', 'nope' as never), /invalid/);
});
-27
View File
@@ -1,27 +0,0 @@
import type { CryptoCallbacks } from 'matrix-js-sdk/lib/crypto-api';
const secretStorageKeys = new Map<string, Uint8Array<ArrayBuffer>>();
export function storePrivateKey(keyId: string, privateKey: Uint8Array) {
if (privateKey instanceof Uint8Array === false) {
throw new Error('Unable to store, privateKey is invalid.');
}
// Our own copy, on a plain ArrayBuffer (what the SDK's callback type wants).
secretStorageKeys.set(keyId, new Uint8Array(privateKey));
}
export function clearSecretStorageKeys() {
secretStorageKeys.clear();
}
export const cryptoCallbacks: CryptoCallbacks = {
async getSecretStorageKey({ keys }) {
const keyId = Object.keys(keys).find((id) => secretStorageKeys.get(id) instanceof Uint8Array);
const privateKey = keyId ? secretStorageKeys.get(keyId) : undefined;
// The SDK expects null (not undefined) when no key is cached.
return keyId && privateKey ? [keyId, privateKey] : null;
},
cacheSecretStorageKey(keyId, keyInfo, privateKey) {
secretStorageKeys.set(keyId, privateKey);
},
};
+11 -1
View File
@@ -189,7 +189,17 @@ function lotusDenoise() {
'Run `npm ci` to install @workadventure/noise-suppression.',
);
}
fs.cpSync(dtln[0], path.join(denoiseDir, dtln[1]), { recursive: true });
// [Gitea #210] Ship only what can load. The threaded LiteRT build is used
// only on a cross-origin-isolated page (COOP + COEP), and neither the web
// call page nor the desktop one is, so its ~9 MB never loads; source maps
// and type declarations aren't needed at runtime either. If the call page
// ever turns on COOP/COEP, drop the `threaded` exclusion.
const dtlnSkip = (src) =>
/litert_wasm_threaded_internal\./.test(src) || /\.(map|d\.ts)$/.test(src);
fs.cpSync(dtln[0], path.join(denoiseDir, dtln[1]), {
recursive: true,
filter: (src) => !dtlnSkip(src),
});
const dfnMissing = dfn.filter(([s]) => !fs.existsSync(s)).map(([s]) => s);
if (dfnMissing.length > 0) {