Skip to content

Send files directly between devices over the internet - no cloud storage, no size limits.

Add stop/resume to file transfers (#64)

Denis Lupookova49870189153
diff --git a/apps/desktop/src/renderer/pages/ReceivePage/ReceiveConnectedView.tsx b/apps/desktop/src/renderer/pages/ReceivePage/ReceiveConnectedView.tsx
index 8de0f63..417b28d 100644
--- a/apps/desktop/src/renderer/pages/ReceivePage/ReceiveConnectedView.tsx
+++ b/apps/desktop/src/renderer/pages/ReceivePage/ReceiveConnectedView.tsx
@@ -1,127 +1,67 @@
-import { Fragment, useMemo, useState } from 'react'
-import { Button, LinkRow, ReceivedTextRow, useTheme } from '@altersend/components'
-import { ChevronRightIcon, DownloadIcon, FolderIcon } from '@altersend/components/icons'
+import { Button, DownloadRow, ReceivedTextRow, RowGroup, rowKey } from '@altersend/components'
+import { DownloadIcon, PlayIcon } from '@altersend/components/icons'
import { useTranslation } from '@altersend/locales'
import { bridgeApi } from '../../api/bridgeApi'
import { useToast } from '../../components/Toast'
import { isAskEveryTime } from '../../lifecycle/downloadLocationStorage'
import {
clearSession,
- createDirectoryDownloadRequests,
- createSingleDownloadRequest,
- downloadFiles,
- getDownloadRowDisplay,
- getDownloadTotals,
- getFolderRowDisplay,
+ getDownloadRowLabels,
+ getPrimaryDownloadLabel,
getOfferKey,
- groupReceiveRows,
useCopiedFlag,
- useTransferStore
+ useReceiveActions,
+ useReceiveDownloads
} from '@altersend/domain'
-import type { IncomingFileOffer } from '@altersend/core'
-
-type FileOffer = Extract<IncomingFileOffer, { kind: 'file' }>
-type TextOffer = Extract<IncomingFileOffer, { kind: 'text' }>
-type DownloadRow = ReturnType<typeof getDownloadRowDisplay>
function toSafeFileName(name: string): string {
const base = name.split(/[/\\]/).pop() ?? ''
return base.replace(/\0/g, '').trim() || 'file'
}
-function getDownloadStatusLabel(t: ReturnType<typeof useTranslation>['t'], row: DownloadRow) {
- switch (row.status.kind) {
- case 'saved':
- return t('receive:status.saved')
- case 'failed':
- return t('errors:transfer.downloadFailed')
- case 'progress':
- return t('receive:status.percent', { percent: row.percent })
- case 'ready':
- return t('receive:status.ready')
- }
+function openSavedFile(filePath: string): void {
+ bridgeApi
+ .openFile(filePath)
+ .then((err) => {
+ if (err) console.error('ReceiveConnectedView: failed to open', filePath, err)
+ })
+ .catch((err) => console.error('ReceiveConnectedView: failed to open', filePath, err))
}
export function ReceiveConnectedView() {
const { t } = useTranslation(['receive', 'common', 'errors'])
- const { theme } = useTheme()
const toast = useToast()
- const incomingFileOffers = useTransferStore((s) => s.incomingFileOffers)
- const downloadStates = useTransferStore((s) => s.receiveDownloadStates)
- const peerCount = useTransferStore((s) => s.peerCount)
- const [expandedFolders, setExpandedFolders] = useState<Set<string>>(new Set())
const { copiedId, flashCopied } = useCopiedFlag()
-
- const textOffers = useMemo(
- () => incomingFileOffers.filter((offer): offer is TextOffer => offer.kind === 'text'),
- [incomingFileOffers]
- )
- const rows = useMemo(() => groupReceiveRows(incomingFileOffers), [incomingFileOffers])
- const totals = useMemo(
- () => getDownloadTotals(incomingFileOffers, downloadStates),
- [downloadStates, incomingFileOffers]
- )
-
- const toggleFolder = (name: string) =>
- setExpandedFolders((prev) => {
- const next = new Set(prev)
- if (next.has(name)) next.delete(name)
- else next.add(name)
- return next
- })
-
- const statusFor = (row: DownloadRow) =>
- row.status.kind === 'ready'
- ? undefined
- : { label: getDownloadStatusLabel(t, row), tone: row.status.tone }
-
- const renderFileRow = (offer: FileOffer, isFirst = false) => {
- const row = getDownloadRowDisplay(offer, downloadStates[getOfferKey(offer)])
- return (
- <LinkRow
- key={getOfferKey(offer)}
- file
- bare
- compact
- isFirst={isFirst}
- label={offer.name}
- size={offer.size}
- description={row.description}
- status={statusFor(row)}
- progressPercent={row.progressPercent}
- />
- )
- }
+ const downloads = useReceiveDownloads()
+ const actions = useReceiveActions(downloads)
const copyText = (id: string, content: string) => {
void navigator.clipboard.writeText(content)
flashCopied(id)
}
- const fileOffers = incomingFileOffers.filter((f): f is FileOffer => f.kind === 'file')
- const hasDownloadableFiles = fileOffers.length > 0
- const isDownloading = totals.activeCount > 0
- const allFilesDownloaded = hasDownloadableFiles && totals.completedCount === fileOffers.length
-
const downloadWithDialog = async () => {
- const isSingleLooseFile = rows.length === 1 && rows[0].kind === 'file'
+ const isSingleLooseFile =
+ downloads.pendingOffers.length === 1 &&
+ downloads.rows.length === 1 &&
+ downloads.rows[0].kind === 'file'
if (isSingleLooseFile) {
- const selected = await bridgeApi.pickSaveFile(toSafeFileName(fileOffers[0].name))
+ const selected = await bridgeApi.pickSaveFile(toSafeFileName(downloads.pendingOffers[0].name))
if (!selected?.path) return
- await downloadFiles([createSingleDownloadRequest(fileOffers[0], selected.path)])
+ await actions.replaceWith(downloads.pendingOffers[0], selected.path)
return
}
const selectedDirectory = await bridgeApi.pickDirectory()
if (!selectedDirectory) return
- await downloadFiles(createDirectoryDownloadRequests(fileOffers, selectedDirectory))
+ await actions.downloadInto(selectedDirectory)
}
const downloadAll = async () => {
- if (fileOffers.length === 0 || isDownloading) return
+ if (downloads.pendingOffers.length === 0 || downloads.isDownloading) return
try {
if (isAskEveryTime()) {
@@ -135,7 +75,7 @@ export function ReceiveConnectedView() {
return
}
- await downloadFiles(createDirectoryDownloadRequests(fileOffers, folder))
+ await actions.downloadInto(folder)
} catch (error) {
console.error('ReceiveConnectedView: download failed', error)
toast.show({ title: t('errors:transfer.downloadFailed'), variant: 'error' })
@@ -145,71 +85,45 @@ export function ReceiveConnectedView() {
return (
<div className='flex h-full min-h-0 w-full flex-1 flex-col'>
<div className='flex min-h-0 flex-1 flex-col gap-6 overflow-y-auto pr-1'>
- {rows.length > 0 ? (
- <div>
- <p className='m-0 mb-2 text-[13px] font-medium text-text-muted'>
- {t('common:files.files')}
- </p>
- <div className='overflow-hidden rounded-[10px] border border-border-primary bg-background-subtle'>
- {rows.map((row, index) => {
- if (row.kind === 'file') return renderFileRow(row.offer, index === 0)
-
- const folder = getFolderRowDisplay(row.offers, downloadStates)
- const isExpanded = expandedFolders.has(row.name)
- return (
- <Fragment key={`folder:${row.name}`}>
- <LinkRow
- icon={<FolderIcon size={16} />}
- bare
- compact
- isFirst={index === 0}
- label={row.name}
- size={row.totalSize}
- description={folder.description}
- status={statusFor(folder)}
- progressPercent={folder.progressPercent}
- onPress={() => toggleFolder(row.name)}
- trailing={
- <span
- className={`inline-flex transition-transform duration-200 ${isExpanded ? 'rotate-90' : ''}`}
- >
- <ChevronRightIcon size={14} color={theme.colors.colorTextMuted} />
- </span>
- }
- />
- {isExpanded ? (
- <div className='pl-10'>{row.offers.map((offer) => renderFileRow(offer))}</div>
- ) : null}
- </Fragment>
- )
- })}
- </div>
- </div>
+ {downloads.rows.length > 0 ? (
+ <RowGroup title={t('common:files.files')}>
+ {downloads.rows.map((row, index) => (
+ <DownloadRow
+ key={rowKey(row)}
+ row={row}
+ states={downloads.states}
+ labelsFor={(display) => getDownloadRowLabels(t, display)}
+ transferActive={downloads.isDownloading}
+ isFirst={index === 0}
+ compact
+ onResume={actions.resumeFile}
+ onPause={actions.pauseFile}
+ onOpen={(_offer, savedTo) => openSavedFile(savedTo)}
+ onPauseFolder={actions.pauseFolder}
+ onResumeFolder={actions.resumeFolder}
+ />
+ ))}
+ </RowGroup>
) : null}
- {textOffers.length > 0 ? (
- <div>
- <p className='m-0 mb-2 text-[13px] font-medium text-text-muted'>
- {t('common:files.text')}
- </p>
- <div className='overflow-hidden rounded-[10px] border border-border-primary bg-background-subtle'>
- {textOffers.map((offer, index) => (
- <ReceivedTextRow
- key={getOfferKey(offer)}
- content={offer.content}
- isFirst={index === 0}
- copied={copiedId === offer.id}
- subtitleLabel={t('common:files.text')}
- copyLabel={t('common:actions.copyText')}
- copiedLabel={t('common:actions.copied')}
- showMoreLabel={t('common:actions.showMore')}
- showLessLabel={t('common:actions.showLess')}
- onCopy={() => copyText(offer.id, offer.content)}
- onOpenLink={(url) => void bridgeApi.openExternalUrl(url)}
- />
- ))}
- </div>
- </div>
+ {downloads.textOffers.length > 0 ? (
+ <RowGroup title={t('common:files.text')}>
+ {downloads.textOffers.map((offer, index) => (
+ <ReceivedTextRow
+ key={getOfferKey(offer)}
+ content={offer.content}
+ isFirst={index === 0}
+ copied={copiedId === offer.id}
+ subtitleLabel={t('common:files.text')}
+ copyLabel={t('common:actions.copyText')}
+ copiedLabel={t('common:actions.copied')}
+ showMoreLabel={t('common:actions.showMore')}
+ showLessLabel={t('common:actions.showLess')}
+ onCopy={() => copyText(offer.id, offer.content)}
+ onOpenLink={(url) => void bridgeApi.openExternalUrl(url)}
+ />
+ ))}
+ </RowGroup>
) : null}
</div>
@@ -218,17 +132,30 @@ export function ReceiveConnectedView() {
<Button onClick={clearSession} size='sm' variant='secondary'>
{t('common:actions.endSession')}
</Button>
- {hasDownloadableFiles && peerCount > 0 && !allFilesDownloaded ? (
+ {downloads.primaryAction ? (
<Button
- disabled={isDownloading}
- icon={<DownloadIcon size={14} />}
- onClick={() => downloadAll().catch(console.error)}
+ disabled={downloads.primaryAction === 'downloading'}
+ icon={
+ downloads.primaryAction === 'resume-all' ? (
+ <PlayIcon size={14} />
+ ) : (
+ <DownloadIcon size={14} />
+ )
+ }
+ loading={downloads.primaryAction === 'downloading'}
+ onClick={() =>
+ (downloads.primaryAction === 'resume-all'
+ ? actions.resumeAll()
+ : downloadAll()
+ ).catch(console.error)
+ }
size='sm'
- variant='primary'
+ variant={downloads.primaryAction === 'downloading' ? 'secondary' : 'primary'}
>
- {isDownloading
- ? t('receive:actions.downloadingPercent', { percent: totals.percent })
- : t('receive:actions.downloadAll')}
+ {getPrimaryDownloadLabel(t, downloads.primaryAction, {
+ percent: downloads.totals.percent,
+ totalBytes: downloads.totals.totalBytes
+ })}
</Button>
) : null}
</div>
diff --git a/apps/desktop/src/renderer/pages/ReceivePage/index.tsx b/apps/desktop/src/renderer/pages/ReceivePage/index.tsx
index d35ab06..5b4afc5 100644
--- a/apps/desktop/src/renderer/pages/ReceivePage/index.tsx
+++ b/apps/desktop/src/renderer/pages/ReceivePage/index.tsx
@@ -1,4 +1,3 @@
-import { useMemo } from 'react'
import { Button } from '@altersend/components'
import { InfoIcon } from '@altersend/components/icons'
import { useTranslation } from '@altersend/locales'
@@ -11,34 +10,26 @@ import { ReceiveJoinView } from './ReceiveJoinView'
import {
clearSession,
- getDownloadTotals,
getReceivePageCopy,
getReceiveStep,
isConnectedStep,
+ useReceiveDownloads,
useTransferStore
} from '@altersend/domain'
export default function ReceivePage() {
const { t } = useTranslation(['receive', 'common'])
const role = useTransferStore((s) => s.role)
- const incomingFileOffers = useTransferStore((s) => s.incomingFileOffers)
- const receiveDownloadStates = useTransferStore((s) => s.receiveDownloadStates)
const peerCount = useTransferStore((s) => s.peerCount)
const connectionType = useTransferStore((s) => s.connectionType)
- const hasIncomingFiles = incomingFileOffers.length > 0
- const totals = useMemo(
- () => getDownloadTotals(incomingFileOffers, receiveDownloadStates),
- [incomingFileOffers, receiveDownloadStates]
- )
- const fileCount = incomingFileOffers.filter((f) => f.kind === 'file').length
- const textCount = incomingFileOffers.length - fileCount
- const hasDownloadableFiles = fileCount > 0
- const allDownloadsCompleted = hasDownloadableFiles && totals.completedCount === fileCount
+ const { totals, fileOffers, textOffers, allDownloaded } = useReceiveDownloads()
+ const fileCount = fileOffers.length
+ const textCount = textOffers.length
const step = getReceiveStep({
- hasIncomingFiles,
- allDownloadsCompleted,
+ hasIncomingFiles: fileCount + textCount > 0,
+ allDownloadsCompleted: allDownloaded,
role,
peerCount
})
diff --git a/apps/mobile/app/(tabs)/receive/index.tsx b/apps/mobile/app/(tabs)/receive/index.tsx
index c2c4edf..50eb1d0 100644
--- a/apps/mobile/app/(tabs)/receive/index.tsx
+++ b/apps/mobile/app/(tabs)/receive/index.tsx
@@ -5,9 +5,9 @@ import { useFocusEffect, useRouter } from 'expo-router'
import {
JOIN_CODE_PATTERN,
getDisplayError,
- getDownloadTotals,
getReceivePageCopy,
getReceiveStep,
+ useReceiveDownloads,
useTransferStore
} from '@altersend/domain'
import { clearSession, joinSession } from '@altersend/domain'
@@ -62,18 +62,12 @@ export default function ReceiveScreen() {
}
}
- const hasIncomingFiles = incomingFileOffers.length > 0
- const totals = useMemo(
- () => getDownloadTotals(incomingFileOffers, receiveDownloadStates),
- [incomingFileOffers, receiveDownloadStates]
- )
- const downloadableFileCount = incomingFileOffers.filter((offer) => offer.kind === 'file').length
- const allDownloadsCompleted =
- downloadableFileCount > 0 && totals.completedCount === downloadableFileCount
+ const { totals, fileOffers, textOffers, allDownloaded } = useReceiveDownloads()
+ const downloadableFileCount = fileOffers.length
const step = getReceiveStep({
- hasIncomingFiles,
- allDownloadsCompleted,
+ hasIncomingFiles: downloadableFileCount + textOffers.length > 0,
+ allDownloadsCompleted: allDownloaded,
role,
peerCount,
isReconnecting
diff --git a/apps/mobile/app/receive/complete.tsx b/apps/mobile/app/receive/complete.tsx
index 855a7ff..fea01bb 100644
--- a/apps/mobile/app/receive/complete.tsx
+++ b/apps/mobile/app/receive/complete.tsx
@@ -6,6 +6,7 @@ import { clearSession } from '@altersend/domain'
import { mobileApi } from '@/src/api/mobileApi'
import { Layout } from '@/src/components'
import { ReceiveCompleteView } from '@/src/transfer/receive'
+import { exitToReceiveTab } from '@/src/transfer/receive/utils/exitToReceiveTab'
export default function ReceiveCompleteScreen() {
const { t } = useTranslation(['receive', 'common'])
const router = useRouter()
@@ -18,7 +19,7 @@ export default function ReceiveCompleteScreen() {
const handleDone = () => {
clearSession()
- if (router.canDismiss()) router.dismissAll()
+ exitToReceiveTab(router)
}
return (
diff --git a/apps/mobile/app/receive/incoming.tsx b/apps/mobile/app/receive/incoming.tsx
index 9be84cd..bd75fef 100644
--- a/apps/mobile/app/receive/incoming.tsx
+++ b/apps/mobile/app/receive/incoming.tsx
@@ -1,24 +1,25 @@
-import { useCallback, useEffect, useMemo } from 'react'
+import { useCallback, useEffect } from 'react'
import { View, StyleSheet, Pressable } from 'react-native'
import { Paths } from 'expo-file-system'
import { Button, useTheme } from '@altersend/components'
-import { ArrowLeftIcon, DownloadIcon, InfoIcon } from '@altersend/components/icons'
+import { ArrowLeftIcon, DownloadIcon, InfoIcon, PlayIcon } from '@altersend/components/icons'
import { useTranslation } from '@altersend/locales'
import { useNavigation, useRouter } from 'expo-router'
import { uriToPath } from '@/src/api/mobileApi'
import { Layout, IllustrationLayout } from '@/src/components'
import { ErrorPanel, ReceiveIncomingView, ReceiveReconnectingView } from '@/src/transfer/receive'
+import { exitToReceiveTab } from '@/src/transfer/receive/utils/exitToReceiveTab'
import ConnectionLostSvg from '../../../../assets/connection-lost.svg'
import {
- createDirectoryDownloadRequests,
- formatFileSize,
getDisplayError,
- getDownloadTotals,
+ getPrimaryDownloadLabel,
getReceivePageCopy,
getReceiveStep,
+ useReceiveActions,
+ useReceiveDownloads,
useTransferStore
} from '@altersend/domain'
-import { clearSession, downloadFiles } from '@altersend/domain'
+import { clearSession } from '@altersend/domain'
import { Text } from '@/src/components/ThemedText'
export default function ReceiveIncomingScreen() {
@@ -27,7 +28,8 @@ export default function ReceiveIncomingScreen() {
const navigation = useNavigation()
const router = useRouter()
const incomingFileOffers = useTransferStore((s) => s.incomingFileOffers)
- const receiveDownloadStates = useTransferStore((s) => s.receiveDownloadStates)
+ const downloads = useReceiveDownloads()
+ const actions = useReceiveActions(downloads)
const role = useTransferStore((s) => s.role)
const peerCount = useTransferStore((s) => s.peerCount)
const connectionType = useTransferStore((s) => s.connectionType)
@@ -35,24 +37,16 @@ export default function ReceiveIncomingScreen() {
const errorCode = useTransferStore((s) => s.errorCode)
const displayError = getDisplayError(t, errorCode)
- const totals = useMemo(
- () => getDownloadTotals(incomingFileOffers, receiveDownloadStates),
- [incomingFileOffers, receiveDownloadStates]
- )
-
+ const { totals, fileOffers, allDownloaded } = downloads
const hasIncomingFiles = incomingFileOffers.length > 0
- const downloadableFileCount = incomingFileOffers.filter((offer) => offer.kind === 'file').length
- const hasDownloadableFiles = downloadableFileCount > 0
- const allDownloadsCompleted =
- hasDownloadableFiles && totals.completedCount === downloadableFileCount
+ const downloadableFileCount = fileOffers.length
const step = getReceiveStep({
hasIncomingFiles,
- allDownloadsCompleted,
+ allDownloadsCompleted: allDownloaded,
role,
peerCount,
isReconnecting
})
- const isDownloading = totals.activeCount > 0
useEffect(() => {
if (step === 'completed') {
@@ -62,7 +56,7 @@ export default function ReceiveIncomingScreen() {
const handleEndSession = useCallback(() => {
void clearSession()
- if (router.canDismiss()) router.dismissAll()
+ exitToReceiveTab(router)
}, [router])
useEffect(() => {
@@ -96,17 +90,17 @@ export default function ReceiveIncomingScreen() {
totalBytes
)
- const handleDownloadAll = async () => {
- if (incomingFileOffers.length === 0 || isDownloading) return
- const targetDir = uriToPath(Paths.document.uri)
+ const handlePrimaryAction = async () => {
try {
- await downloadFiles(createDirectoryDownloadRequests(incomingFileOffers, targetDir))
+ if (downloads.primaryAction === 'resume-all') await actions.resumeAll()
+ else if (downloads.primaryAction === 'download-all') {
+ await actions.downloadInto(uriToPath(Paths.document.uri))
+ }
} catch (err) {
- console.warn('ReceiveIncomingScreen: downloadFiles failed', err)
+ console.warn('ReceiveIncomingScreen: download failed', err)
}
}
- const sizeLabel = totalBytes > 0 ? ` (${formatFileSize(totalBytes)})` : ''
const isReconnectingStep = step === 'reconnecting'
const endSessionButton = (
@@ -181,20 +175,25 @@ export default function ReceiveIncomingScreen() {
hasNativeHeader
footer={
<View style={styles.footerStack}>
- {hasDownloadableFiles ? (
+ {downloads.primaryAction ? (
<Button
- disabled={isDownloading}
- icon={<DownloadIcon size={18} color={theme.colors.colorOnAccent} />}
- onClick={() => void handleDownloadAll()}
+ icon={
+ downloads.primaryAction === 'resume-all' ? (
+ <PlayIcon size={18} />
+ ) : (
+ <DownloadIcon size={18} />
+ )
+ }
+ loading={downloads.primaryAction === 'downloading'}
+ onClick={() => void handlePrimaryAction()}
size='lg'
variant='light'
width='full'
>
- {isDownloading
- ? t('receive:actions.downloadingPercent', { percent: totals.percent })
- : sizeLabel
- ? t('receive:actions.downloadAllWithSize', { size: formatFileSize(totalBytes) })
- : t('receive:actions.downloadAll')}
+ {getPrimaryDownloadLabel(t, downloads.primaryAction, {
+ percent: totals.percent,
+ totalBytes
+ })}
</Button>
) : null}
{endSessionButton}
diff --git a/apps/mobile/package.json b/apps/mobile/package.json
index 7f36691..c33fb9f 100644
--- a/apps/mobile/package.json
+++ b/apps/mobile/package.json
@@ -5,7 +5,7 @@
"description": "AlterSend mobile app (React Native / Expo)",
"main": "expo-router/entry",
"scripts": {
- "build:packages": "cd ../.. && npm run build -w packages/core && npm run build -w packages/locales && npm run build -w packages/domain && npm run build -w packages/components",
+ "build:packages": "cd ../.. && npm run build -w packages/drive && npm run build -w packages/core && npm run build -w packages/locales && npm run build -w packages/domain && npm run build -w packages/components",
"prestart": "npm run build:packages && npm run bundle-bare",
"start": "expo start --dev-client",
"postinstall": "npm run barekit:link-ios-addons && npm run barekit:link-android-addons",
diff --git a/apps/mobile/src/transfer/receive/utils/exitToReceiveTab.ts b/apps/mobile/src/transfer/receive/utils/exitToReceiveTab.ts
new file mode 100644
index 0000000..cdb03ca
--- /dev/null
+++ b/apps/mobile/src/transfer/receive/utils/exitToReceiveTab.ts
@@ -0,0 +1,11 @@
+import type { useRouter } from 'expo-router'
+
+type Router = ReturnType<typeof useRouter>
+
+export function exitToReceiveTab(router: Router): void {
+ if (router.canDismiss()) {
+ router.dismissTo('/(tabs)/receive')
+ return
+ }
+ router.replace('/(tabs)/receive')
+}
diff --git a/apps/mobile/src/transfer/receive/views/ReceiveIncomingView.tsx b/apps/mobile/src/transfer/receive/views/ReceiveIncomingView.tsx
index 805912c..b2f9646 100644
--- a/apps/mobile/src/transfer/receive/views/ReceiveIncomingView.tsx
+++ b/apps/mobile/src/transfer/receive/views/ReceiveIncomingView.tsx
@@ -1,36 +1,31 @@
import { Linking, View, StyleSheet } from 'react-native'
import * as Clipboard from 'expo-clipboard'
-import { LinkRow, ReceivedTextRow, useTheme } from '@altersend/components'
+import { DownloadRow, ReceivedTextRow, RowGroup, rowKey, useTheme } from '@altersend/components'
import {
- getDownloadRowDisplay,
+ getDownloadRowLabels,
getOfferKey,
useCopiedFlag,
- useTransferStore
+ useReceiveActions,
+ useReceiveDownloads
} from '@altersend/domain'
import { useTranslation } from '@altersend/locales'
+import { openCompletedFile } from '../utils/openCompletedFile'
import { Text } from '@/src/components/ThemedText'
export function ReceiveIncomingView() {
- const { t } = useTranslation(['receive', 'common'])
- const incomingFileOffers = useTransferStore((s) => s.incomingFileOffers)
- const downloadStates = useTransferStore((s) => s.receiveDownloadStates)
+ const { t } = useTranslation(['receive', 'common', 'errors'])
const { theme } = useTheme()
const c = theme.colors
const { copiedId, flashCopied } = useCopiedFlag()
+ const downloads = useReceiveDownloads()
+ const actions = useReceiveActions(downloads)
const copyText = (id: string, content: string) => {
void Clipboard.setStringAsync(content)
flashCopied(id)
}
- const fileOffers = incomingFileOffers.filter(
- (o): o is Extract<typeof o, { kind: 'file' }> => o.kind === 'file'
- )
- const textOffers = incomingFileOffers.filter(
- (o): o is Extract<typeof o, { kind: 'text' }> => o.kind === 'text'
- )
-
- if (incomingFileOffers.length === 0) {
+ if (!downloads.hasFiles && downloads.textOffers.length === 0) {
return (
<View style={styles.container}>
<Text style={[styles.waitingText, { color: c.colorTextMuted }]}>
@@ -40,61 +35,46 @@ export function ReceiveIncomingView() {
)
}
- const cardStyle = [
- styles.card,
- { borderColor: c.colorBorderPrimary, backgroundColor: c.colorBackgroundSubtle }
- ]
-
return (
<View style={styles.container}>
- {fileOffers.length > 0 ? (
- <View style={styles.section}>
- <Text style={[styles.heading, { color: c.colorTextMuted }]}>
- {t('common:files.files')}
- </Text>
- <View style={cardStyle}>
- {fileOffers.map((offer, index) => {
- const row = getDownloadRowDisplay(offer, downloadStates[getOfferKey(offer)])
- return (
- <LinkRow
- key={getOfferKey(offer)}
- file
- bare
- isFirst={index === 0}
- label={offer.name}
- size={offer.size}
- description={row.isActive ? `${row.description} · ${row.percent}%` : undefined}
- progressPercent={row.isActive || row.isCompleted ? row.percent : undefined}
- />
- )
- })}
- </View>
- </View>
+ {downloads.hasFiles ? (
+ <RowGroup title={t('common:files.files')}>
+ {downloads.rows.map((row, index) => (
+ <DownloadRow
+ key={rowKey(row)}
+ row={row}
+ states={downloads.states}
+ labelsFor={(display) => getDownloadRowLabels(t, display)}
+ transferActive={downloads.isDownloading}
+ isFirst={index === 0}
+ onResume={actions.resumeFile}
+ onPause={actions.pauseFile}
+ onOpen={(offer) => openCompletedFile(getOfferKey(offer))}
+ onPauseFolder={actions.pauseFolder}
+ onResumeFolder={actions.resumeFolder}
+ />
+ ))}
+ </RowGroup>
) : null}
- {textOffers.length > 0 ? (
- <View style={styles.section}>
- <Text style={[styles.heading, { color: c.colorTextMuted }]}>
- {t('common:files.text')}
- </Text>
- <View style={cardStyle}>
- {textOffers.map((offer, index) => (
- <ReceivedTextRow
- key={getOfferKey(offer)}
- content={offer.content}
- isFirst={index === 0}
- copied={copiedId === offer.id}
- subtitleLabel={t('common:files.text')}
- copyLabel={t('common:actions.copyText')}
- copiedLabel={t('common:actions.copied')}
- showMoreLabel={t('common:actions.showMore')}
- showLessLabel={t('common:actions.showLess')}
- onCopy={() => copyText(offer.id, offer.content)}
- onOpenLink={(url) => void Linking.openURL(url)}
- />
- ))}
- </View>
- </View>
+ {downloads.textOffers.length > 0 ? (
+ <RowGroup title={t('common:files.text')}>
+ {downloads.textOffers.map((offer, index) => (
+ <ReceivedTextRow
+ key={getOfferKey(offer)}
+ content={offer.content}
+ isFirst={index === 0}
+ copied={copiedId === offer.id}
+ subtitleLabel={t('common:files.text')}
+ copyLabel={t('common:actions.copyText')}
+ copiedLabel={t('common:actions.copied')}
+ showMoreLabel={t('common:actions.showMore')}
+ showLessLabel={t('common:actions.showLess')}
+ onCopy={() => copyText(offer.id, offer.content)}
+ onOpenLink={(url) => void Linking.openURL(url)}
+ />
+ ))}
+ </RowGroup>
) : null}
</View>
)
@@ -105,18 +85,6 @@ const styles = StyleSheet.create({
flex: 1,
gap: 20
},
- section: {
- gap: 8
- },
- heading: {
- fontSize: 13,
- fontWeight: '500'
- },
- card: {
- borderRadius: 12,
- borderWidth: 1,
- overflow: 'hidden'
- },
waitingText: {
fontSize: 13
}
diff --git a/package-lock.json b/package-lock.json
index e58dfa8..151a0b0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -27414,7 +27414,8 @@
"dependencies": {
"bare-fs": "^4.7.0",
"bare-path": "^3.0.0",
- "blake2b": "^2.1.4"
+ "blake2b": "^2.1.4",
+ "blake2b-wasm": "^2.4.0"
},
"devDependencies": {
"@types/node": "^22.10.0",
diff --git a/package.json b/package.json
index e91ceec..c86627f 100644
--- a/package.json
+++ b/package.json
@@ -21,7 +21,7 @@
"components:typecheck": "npm run typecheck -w packages/components",
"components:storybook": "npm run storybook -w packages/components",
"components:build-storybook": "npm run build-storybook -w packages/components",
- "build": "npm run build -w packages/core && npm run build -w packages/drive && npm run build -w packages/locales && npm run build -w packages/domain && npm run build -w packages/components && npm run build --if-present -w apps/desktop",
+ "build": "npm run build -w packages/drive && npm run build -w packages/core && npm run build -w packages/locales && npm run build -w packages/domain && npm run build -w packages/components && npm run build --if-present -w apps/desktop",
"test": "npm test --workspaces --if-present",
"lint": "eslint apps packages --max-warnings=0",
"format": "prettier --write \"apps/**/*.{ts,tsx,js,jsx,json,md,yml,yaml}\" \"packages/**/*.{ts,tsx,js,jsx,json,md,yml,yaml}\" \"*.md\" \"docs/**/*.md\"",
diff --git a/packages/components/src/components/DownloadRow/DownloadRow.tsx b/packages/components/src/components/DownloadRow/DownloadRow.tsx
new file mode 100644
index 0000000..dd45fe9
--- /dev/null
+++ b/packages/components/src/components/DownloadRow/DownloadRow.tsx
@@ -0,0 +1,182 @@
+import { useState } from 'react'
+import { html } from 'react-strict-dom'
+import {
+ getDownloadRowAction,
+ getDownloadRowDisplay,
+ getFolderRowAction,
+ getFolderRowDisplay,
+ getOfferKey,
+ type DownloadItemState,
+ type DownloadRowDisplay,
+ type DownloadRowAction,
+ type DownloadRowLabels,
+ type ReceiveRow
+} from '@altersend/domain'
+import type { IncomingFileOffer } from '@altersend/core'
+import { LinkRow } from '../LinkRow'
+import { ChevronRightIcon, FolderIcon } from '../../icons'
+import { useTheme } from '../../theme'
+import { RowActionButton } from './RowActionButton'
+import { styles } from './styles'
+
+type FileOffer = Extract<IncomingFileOffer, { kind: 'file' }>
+
+export function rowKey(row: ReceiveRow): string {
+ return row.kind === 'file' ? getOfferKey(row.offer) : `folder:${row.name}`
+}
+
+export interface DownloadRowProps {
+ row: ReceiveRow
+ states: Record<string, DownloadItemState>
+ labelsFor: (display: DownloadRowDisplay) => DownloadRowLabels
+ transferActive: boolean
+ isFirst?: boolean
+ compact?: boolean
+ onResume: (offer: FileOffer, targetPath: string) => void
+ onPause: (offer: FileOffer) => void
+ onOpen: (offer: FileOffer, savedTo: string) => void
+ onPauseFolder: (offers: FileOffer[]) => void
+ onResumeFolder: (offers: FileOffer[]) => void
+}
+
+type RowHandlers = Pick<DownloadRowProps, 'onResume' | 'onPause' | 'onOpen'>
+
+interface FileRowProps extends RowHandlers {
+ offer: FileOffer
+ states: Record<string, DownloadItemState>
+ labelsFor: (display: DownloadRowDisplay) => DownloadRowLabels
+ transferActive: boolean
+ isFirst?: boolean
+ compact?: boolean
+}
+
+function runRowAction(
+ action: NonNullable<DownloadRowAction>,
+ offer: FileOffer,
+ handlers: RowHandlers
+): void {
+ switch (action.kind) {
+ case 'resume':
+ return handlers.onResume(offer, action.targetPath)
+ case 'pause':
+ return handlers.onPause(offer)
+ case 'open':
+ return handlers.onOpen(offer, action.savedTo)
+ }
+}
+
+export function DownloadRow(props: DownloadRowProps) {
+ return props.row.kind === 'file' ? (
+ <FileRow {...props} offer={props.row.offer} />
+ ) : (
+ <FolderRow {...props} folder={props.row} />
+ )
+}
+
+function FileRow({
+ offer,
+ states,
+ labelsFor,
+ transferActive,
+ isFirst = false,
+ compact = false,
+ onResume,
+ onPause,
+ onOpen
+}: FileRowProps) {
+ const state = states[getOfferKey(offer)]
+ const display = getDownloadRowDisplay(offer, state, transferActive)
+ const labels = labelsFor(display)
+ const action = getDownloadRowAction(display, state)
+
+ return (
+ <LinkRow
+ file
+ bare
+ compact={compact}
+ isFirst={isFirst}
+ label={offer.name}
+ size={offer.size}
+ description={display.description}
+ status={labels.status ? { label: labels.status, tone: display.status.tone } : undefined}
+ progressPercent={display.progressPercent}
+ trailing={
+ action ? (
+ <RowActionButton
+ kind={action.kind}
+ label={labels[action.kind]}
+ onPress={() => runRowAction(action, offer, { onResume, onPause, onOpen })}
+ />
+ ) : undefined
+ }
+ />
+ )
+}
+
+function FolderRow({
+ folder,
+ states,
+ labelsFor,
+ transferActive,
+ isFirst = false,
+ onResume,
+ onPause,
+ onOpen,
+ onPauseFolder,
+ onResumeFolder
+}: DownloadRowProps & { folder: Extract<ReceiveRow, { kind: 'folder' }> }) {
+ const { theme } = useTheme()
+ const [expanded, setExpanded] = useState(false)
+ const display = getFolderRowDisplay(folder.offers, states)
+ const labels = labelsFor(display)
+ const action = getFolderRowAction(folder.offers, states)
+
+ return (
+ <>
+ <LinkRow
+ icon={<FolderIcon size={16} />}
+ bare
+ compact
+ isFirst={isFirst}
+ label={folder.name}
+ size={folder.totalSize}
+ description={display.description}
+ status={labels.status ? { label: labels.status, tone: display.status.tone } : undefined}
+ progressPercent={display.progressPercent}
+ onPress={() => setExpanded((open) => !open)}
+ trailing={
+ <html.div style={styles.trailing}>
+ {action ? (
+ <RowActionButton
+ kind={action}
+ label={labels[action]}
+ onPress={() =>
+ action === 'pause' ? onPauseFolder(folder.offers) : onResumeFolder(folder.offers)
+ }
+ />
+ ) : null}
+ <html.div style={[styles.chevron, expanded && styles.chevronOpen]}>
+ <ChevronRightIcon size={14} color={theme.colors.colorTextMuted} />
+ </html.div>
+ </html.div>
+ }
+ />
+ {expanded ? (
+ <html.div style={styles.children}>
+ {folder.offers.map((offer) => (
+ <FileRow
+ key={getOfferKey(offer)}
+ offer={offer}
+ states={states}
+ labelsFor={labelsFor}
+ transferActive={transferActive}
+ onResume={onResume}
+ onPause={onPause}
+ onOpen={onOpen}
+ />
+ ))}
+ </html.div>
+ ) : null}
+ </>
+ )
+}
diff --git a/packages/components/src/components/DownloadRow/RowActionButton.tsx b/packages/components/src/components/DownloadRow/RowActionButton.tsx
new file mode 100644
index 0000000..68d78f1
--- /dev/null
+++ b/packages/components/src/components/DownloadRow/RowActionButton.tsx
@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react'
+import { Button } from '../Button'
+import { ArrowUpRightIcon, PauseIcon, PlayIcon } from '../../icons'
+
+export type RowActionKind = 'resume' | 'pause' | 'open'
+
+const ICONS: Record<RowActionKind, ReactNode> = {
+ resume: <PlayIcon size={14} />,
+ pause: <PauseIcon size={14} />,
+ open: <ArrowUpRightIcon size={14} />
+}
+
+export interface RowActionButtonProps {
+ kind: RowActionKind
+ label: string
+ onPress: () => void
+}
+
+export function RowActionButton({ kind, label, onPress }: RowActionButtonProps) {
+ return (
+ <Button
+ aria-label={label}
+ icon={ICONS[kind]}
+ iconOnly
+ onClick={onPress}
+ size='sm'
+ tooltip={label}
+ tooltipSide='left'
+ variant='secondary'
+ />
+ )
+}
diff --git a/packages/components/src/components/DownloadRow/index.ts b/packages/components/src/components/DownloadRow/index.ts
new file mode 100644
index 0000000..2863e51
--- /dev/null
+++ b/packages/components/src/components/DownloadRow/index.ts
@@ -0,0 +1,2 @@
+export * from './DownloadRow'
+export * from './RowActionButton'
diff --git a/packages/components/src/components/DownloadRow/styles.ts b/packages/components/src/components/DownloadRow/styles.ts
new file mode 100644
index 0000000..8d111d6
--- /dev/null
+++ b/packages/components/src/components/DownloadRow/styles.ts
@@ -0,0 +1,22 @@
+import { css } from 'react-strict-dom'
+
+export const styles = css.create({
+ trailing: {
+ display: 'flex',
+ flexDirection: 'row',
+ alignItems: 'center',
+ gap: 4
+ },
+ children: {
+ paddingLeft: 40
+ },
+ chevron: {
+ display: 'flex',
+ alignItems: 'center',
+ transitionProperty: 'transform',
+ transitionDuration: '200ms'
+ },
+ chevronOpen: {
+ transform: 'rotate(90deg)'
+ }
+})
diff --git a/packages/components/src/components/PeerListCard/PeerListCard.tsx b/packages/components/src/components/PeerListCard/PeerListCard.tsx
index 76376db..45cd868 100644
--- a/packages/components/src/components/PeerListCard/PeerListCard.tsx
+++ b/packages/components/src/components/PeerListCard/PeerListCard.tsx
@@ -2,7 +2,13 @@ import { html } from 'react-strict-dom'
import { Button } from '../Button'
import { styles } from './styles'
-export type PeerListCardStatus = 'online' | 'downloading' | 'downloaded' | 'failed' | 'disconnected'
+export type PeerListCardStatus =
+ | 'online'
+ | 'downloading'
+ | 'downloaded'
+ | 'paused'
+ | 'failed'
+ | 'disconnected'
export type PeerPairState = 'pairable' | 'requested' | 'paired'
export interface PeerListCardEntry {
@@ -25,6 +31,7 @@ const DOT_TONE = {
online: styles.dotOnline,
downloading: styles.dotDownloading,
downloaded: styles.dotDownloaded,
+ paused: styles.dotPaused,
failed: styles.dotFailed,
disconnected: styles.dotDisconnected
} as const
@@ -33,6 +40,7 @@ const TEXT_TONE = {
online: styles.textOnline,
downloading: styles.textDownloading,
downloaded: styles.textDownloaded,
+ paused: styles.textPaused,
failed: styles.textFailed,
disconnected: styles.textDisconnected
} as const
diff --git a/packages/components/src/components/PeerListCard/styles.ts b/packages/components/src/components/PeerListCard/styles.ts
index ea2d823..ca35baf 100644
--- a/packages/components/src/components/PeerListCard/styles.ts
+++ b/packages/components/src/components/PeerListCard/styles.ts
@@ -180,11 +180,13 @@ export const styles = css.create({
dotOnline: { backgroundColor: tokens.colorInfo },
dotDownloading: { backgroundColor: tokens.colorInfo },
dotDownloaded: { backgroundColor: tokens.colorSuccess },
+ dotPaused: { backgroundColor: tokens.colorTextMuted },
dotFailed: { backgroundColor: tokens.colorDanger },
dotDisconnected: { backgroundColor: tokens.colorTextMuted },
textOnline: { color: tokens.colorInfo },
textDownloading: { color: tokens.colorInfo },
textDownloaded: { color: tokens.colorSuccess },
+ textPaused: { color: tokens.colorTextMuted },
textFailed: { color: tokens.colorDanger },
textDisconnected: { color: tokens.colorTextMuted }
})
diff --git a/packages/components/src/components/RowGroup/RowGroup.tsx b/packages/components/src/components/RowGroup/RowGroup.tsx
new file mode 100644
index 0000000..a65b706
--- /dev/null
+++ b/packages/components/src/components/RowGroup/RowGroup.tsx
@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react'
+import { html } from 'react-strict-dom'
+import { styles } from './styles'
+
+export interface RowGroupProps {
+ title: string
+ children: ReactNode
+}
+
+export function RowGroup({ title, children }: RowGroupProps) {
+ return (
+ <html.div style={styles.section}>
+ <html.p style={styles.heading}>{title}</html.p>
+ <html.div style={styles.card}>{children}</html.div>
+ </html.div>
+ )
+}
diff --git a/packages/components/src/components/RowGroup/index.ts b/packages/components/src/components/RowGroup/index.ts
new file mode 100644
index 0000000..6e60bf7
--- /dev/null
+++ b/packages/components/src/components/RowGroup/index.ts
@@ -0,0 +1 @@
+export * from './RowGroup'
diff --git a/packages/components/src/components/RowGroup/styles.ts b/packages/components/src/components/RowGroup/styles.ts
new file mode 100644
index 0000000..0c00fa5
--- /dev/null
+++ b/packages/components/src/components/RowGroup/styles.ts
@@ -0,0 +1,24 @@
+import { css } from 'react-strict-dom'
+import { tokens } from '../../theme/tokens.css'
+
+export const styles = css.create({
+ section: {
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 8
+ },
+ heading: {
+ margin: 0,
+ fontSize: 13,
+ fontWeight: '500',
+ color: tokens.colorTextMuted
+ },
+ card: {
+ borderWidth: 1,
+ borderStyle: 'solid',
+ borderColor: tokens.colorBorderPrimary,
+ borderRadius: tokens.radiusLg,
+ overflow: 'hidden',
+ backgroundColor: tokens.colorBackgroundSubtle
+ }
+})
diff --git a/packages/components/src/components/Tooltip/Tooltip.tsx b/packages/components/src/components/Tooltip/Tooltip.tsx
index 1ce4100..d31461d 100644
--- a/packages/components/src/components/Tooltip/Tooltip.tsx
+++ b/packages/components/src/components/Tooltip/Tooltip.tsx
@@ -1,7 +1,7 @@
import { html } from 'react-strict-dom'
import { styles } from './styles'
-export type TooltipSide = 'right' | 'top' | 'bottom'
+export type TooltipSide = 'left' | 'right' | 'top' | 'bottom'
export interface TooltipProps {
label: string
@@ -10,6 +10,7 @@ export interface TooltipProps {
}
const sideStyle = {
+ left: styles.left,
right: styles.right,
top: styles.top,
bottom: styles.bottom
diff --git a/packages/components/src/components/Tooltip/styles.ts b/packages/components/src/components/Tooltip/styles.ts
index f72e392..26eee30 100644
--- a/packages/components/src/components/Tooltip/styles.ts
+++ b/packages/components/src/components/Tooltip/styles.ts
@@ -23,6 +23,14 @@ export const styles = css.create({
marginLeft: tokens.space2,
alignItems: 'center'
},
+ left: {
+ right: '100%',
+ top: 0,
+ bottom: 0,
+ marginRight: tokens.space2,
+ alignItems: 'center',
+ justifyContent: 'flex-end'
+ },
top: {
bottom: '100%',
left: 0,
diff --git a/packages/components/src/components/index.ts b/packages/components/src/components/index.ts
index 9071c36..5c1cc8d 100644
--- a/packages/components/src/components/index.ts
+++ b/packages/components/src/components/index.ts
@@ -1,5 +1,7 @@
export * from './Badge/index'
export * from './Button/index'
+export * from './DownloadRow/index'
+export * from './RowGroup/index'
export * from './Input/index'
export * from './Textarea/index'
export * from './Tabs/index'
diff --git a/packages/components/src/icons/set.tsx b/packages/components/src/icons/set.tsx
index 1b13bc0..6a562e2 100644
--- a/packages/components/src/icons/set.tsx
+++ b/packages/components/src/icons/set.tsx
@@ -36,9 +36,11 @@ import {
MoreVertical,
Music,
PanelLeft,
+ Pause,
PanelLeftClose,
PanelLeftOpen,
Pencil,
+ Play,
Plus,
QrCode,
Send,
@@ -97,7 +99,9 @@ export const MusicIcon = adaptLucide(Music)
export const PanelLeftIcon = adaptLucide(PanelLeft)
export const PanelLeftCloseIcon = adaptLucide(PanelLeftClose)
export const PanelLeftOpenIcon = adaptLucide(PanelLeftOpen)
+export const PauseIcon = adaptLucide(Pause)
export const PencilIcon = adaptLucide(Pencil)
+export const PlayIcon = adaptLucide(Play)
export const PlusIcon = adaptLucide(Plus)
export const QrCodeIcon = adaptLucide(QrCode)
export const SendIcon = adaptLucide(Send)
diff --git a/packages/core/src/worklet/abort/install.ts b/packages/core/src/worklet/abort/install.ts
new file mode 100644
index 0000000..5dc49f3
--- /dev/null
+++ b/packages/core/src/worklet/abort/install.ts
@@ -0,0 +1,11 @@
+import { ManagedAbortController } from './managed-abort-controller'
+import { ManagedAbortSignal } from './managed-abort-signal'
+
+const globals = globalThis as unknown as { AbortController?: unknown; AbortSignal?: unknown }
+
+if (typeof globals.AbortController === 'undefined') {
+ globals.AbortController = ManagedAbortController
+ globals.AbortSignal = ManagedAbortSignal
+}
+
+export {}
diff --git a/packages/core/src/worklet/abort/managed-abort-controller.test.ts b/packages/core/src/worklet/abort/managed-abort-controller.test.ts
new file mode 100644
index 0000000..cab604e
--- /dev/null
+++ b/packages/core/src/worklet/abort/managed-abort-controller.test.ts
@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest'
+import { ManagedAbortController } from './managed-abort-controller'
+
+describe('ManagedAbortController', () => {
+ it('notifies listeners when aborted', () => {
+ const controller = new ManagedAbortController()
+ let notified = false
+ controller.signal.addEventListener('abort', () => {
+ notified = true
+ })
+ controller.abort()
+ expect(notified).toBe(true)
+ expect(controller.signal.aborted).toBe(true)
+ })
+
+ it('runs a listener added after the abort', () => {
+ const controller = new ManagedAbortController()
+ controller.abort()
+ let notified = false
+ controller.signal.addEventListener('abort', () => {
+ notified = true
+ })
+ expect(notified).toBe(true)
+ })
+
+ it('only fires once', () => {
+ const controller = new ManagedAbortController()
+ let count = 0
+ controller.signal.addEventListener('abort', () => count++)
+ controller.abort()
+ controller.abort()
+ expect(count).toBe(1)
+ })
+
+ it('does not let one throwing listener stop the others', () => {
+ const controller = new ManagedAbortController()
+ let reached = false
+ controller.signal.addEventListener('abort', () => {
+ throw new Error('boom')
+ })
+ controller.signal.addEventListener('abort', () => {
+ reached = true
+ })
+ controller.abort()
+ expect(reached).toBe(true)
+ })
+})
diff --git a/packages/core/src/worklet/abort/managed-abort-controller.ts b/packages/core/src/worklet/abort/managed-abort-controller.ts
new file mode 100644
index 0000000..0dac7af
--- /dev/null
+++ b/packages/core/src/worklet/abort/managed-abort-controller.ts
@@ -0,0 +1,9 @@
+import { ManagedAbortSignal } from './managed-abort-signal'
+
+export class ManagedAbortController {
+ readonly signal: ManagedAbortSignal = new ManagedAbortSignal()
+
+ abort(): void {
+ this.signal.fire()
+ }
+}
diff --git a/packages/core/src/worklet/abort-polyfill.ts b/packages/core/src/worklet/abort/managed-abort-signal.ts
similarity index 54%
rename from packages/core/src/worklet/abort-polyfill.ts
rename to packages/core/src/worklet/abort/managed-abort-signal.ts
index ea2d49a..50cee65 100644
--- a/packages/core/src/worklet/abort-polyfill.ts
+++ b/packages/core/src/worklet/abort/managed-abort-signal.ts
@@ -1,6 +1,6 @@
type AbortListener = () => void
-class PolyfilledAbortSignal {
+export class ManagedAbortSignal {
aborted = false
private readonly listeners = new Set<AbortListener>()
@@ -16,29 +16,16 @@ class PolyfilledAbortSignal {
this.listeners.delete(listener)
}
- _abort(): void {
+ fire(): void {
if (this.aborted) return
this.aborted = true
for (const listener of this.listeners) {
try {
listener()
} catch (err) {
- console.warn('AbortSignal: listener threw', err)
+ console.warn('ManagedAbortSignal: listener threw', err)
}
}
this.listeners.clear()
}
}
-
-class PolyfilledAbortController {
- readonly signal: PolyfilledAbortSignal = new PolyfilledAbortSignal()
- abort(): void {
- this.signal._abort()
- }
-}
-
-const g = globalThis as unknown as { AbortController?: unknown; AbortSignal?: unknown }
-if (typeof g.AbortController === 'undefined') {
- g.AbortController = PolyfilledAbortController
- g.AbortSignal = PolyfilledAbortSignal
-}
diff --git a/packages/core/src/worklet/index.ts b/packages/core/src/worklet/index.ts
index b076a26..1911a17 100644
--- a/packages/core/src/worklet/index.ts
+++ b/packages/core/src/worklet/index.ts
@@ -1,4 +1,4 @@
-import './abort-polyfill'
+import './abort/install'
import './process-handlers'
import 'bare-buffer'
import 'bare-crypto'
@@ -9,6 +9,7 @@ import 'bare-zlib'
import bareProcess from 'bare-process'
import os from 'bare-os'
import fs from 'bare-fs'
+import { ready as hashReady } from '@altersend/drive'
import { TransferOrchestrator } from './transfer/orchestrator'
import { isDeviceType } from './identity/device-type'
import { createReadyEvent } from './rpc/events'
@@ -110,6 +111,12 @@ console.error = (...args: unknown[]) => {
sendTransferEvent(createReadyEvent())
+hashReady()
+ .then((wasm) => {
+ if (!wasm) console.warn('Core: blake2b wasm unavailable, hashing with the js fallback')
+ })
+ .catch((err: unknown) => console.warn('Core: blake2b wasm probe failed', err))
+
let shuttingDown = false
async function gracefulShutdown(_reason: string) {
if (shuttingDown) return
diff --git a/packages/core/src/worklet/rpc/commands.ts b/packages/core/src/worklet/rpc/commands.ts
index 0ea4c33..be4113a 100644
--- a/packages/core/src/worklet/rpc/commands.ts
+++ b/packages/core/src/worklet/rpc/commands.ts
@@ -14,7 +14,8 @@ export const API = {
initDeviceSecret: 12,
hostPairing: 13,
joinPairing: 14,
- setRelayConfig: 15
+ setRelayConfig: 15,
+ pauseDownload: 16
},
channels: {
event: 100,
diff --git a/packages/core/src/worklet/rpc/events.ts b/packages/core/src/worklet/rpc/events.ts
index 5b0558c..777b080 100644
--- a/packages/core/src/worklet/rpc/events.ts
+++ b/packages/core/src/worklet/rpc/events.ts
@@ -53,6 +53,10 @@ export interface StatusEvent {
totalBytes?: number
bytesTransferred?: number
message?: string
+ resumable?: boolean
+ cancelled?: boolean
+ pausable?: boolean
+ paused?: boolean
connectionType?: 'direct' | 'relay'
}
diff --git a/packages/core/src/worklet/rpc/protocol.ts b/packages/core/src/worklet/rpc/protocol.ts
index c8b112a..f6364cf 100644
--- a/packages/core/src/worklet/rpc/protocol.ts
+++ b/packages/core/src/worklet/rpc/protocol.ts
@@ -32,6 +32,7 @@ export interface DownloadFileRequest {
size?: number
targetDir?: string
targetPath?: string
+ overwrite?: boolean
}
export interface HostReply {
@@ -155,6 +156,7 @@ export interface TransferRPC {
shareFiles(files: ShareFileRequest[]): Promise<ShareFilesReply>
downloadFiles(files: DownloadFileRequest[]): Promise<DownloadFilesReply>
+ pauseDownload(fileId: string): Promise<void>
disconnect(): Promise<DisconnectReply>
closePeers(): Promise<void>
rememberVote(input: RememberVoteInput): Promise<RememberVoteReply>
diff --git a/packages/core/src/worklet/rpc/serial-queue.ts b/packages/core/src/worklet/rpc/serial-queue.ts
new file mode 100644
index 0000000..4cd99ac
--- /dev/null
+++ b/packages/core/src/worklet/rpc/serial-queue.ts
@@ -0,0 +1,15 @@
+export class SerialQueue {
+ private tail: Promise<unknown> = Promise.resolve(null)
+
+ constructor(private readonly onError: (err: unknown) => void) {}
+
+ run<T>(task: () => Promise<T>): Promise<T> {
+ const result = this.tail.then(task)
+ this.tail = result.catch(this.onError)
+ return result
+ }
+
+ whenIdle(): Promise<unknown> {
+ return this.tail
+ }
+}
diff --git a/packages/core/src/worklet/rpc/server.ts b/packages/core/src/worklet/rpc/server.ts
index 213e5cf..a68326d 100644
--- a/packages/core/src/worklet/rpc/server.ts
+++ b/packages/core/src/worklet/rpc/server.ts
@@ -7,8 +7,9 @@ import {
encodeRPCError,
encodeRPCSuccess
} from './protocol'
-import type { TransferRPC } from './protocol'
+import type { TransferMethod, TransferRPC } from './protocol'
import { AbortError } from '../transfer/utils'
+import { SerialQueue } from './serial-queue'
type EmitEvent = (message: unknown) => void
@@ -16,24 +17,43 @@ function toError(err: unknown) {
return err instanceof Error ? err : new Error('Unknown worker error')
}
+export function runsWithoutWaiting(method: TransferMethod): boolean {
+ return method === 'pauseDownload'
+}
+
+export function isFileTransfer(method: TransferMethod): boolean {
+ return method === 'downloadFiles'
+}
+
+const DOWNLOAD_DRAIN_TIMEOUT_MS = 5_000
+
export function createTransferWorkerRPCServer(
stream: unknown,
orchestrator: TransferRPC,
emitEvent: EmitEvent,
abortInFlight: () => void = () => {}
) {
- let commandQueue = Promise.resolve<unknown>(null)
+ const reportFailure = (err: unknown) => {
+ if (err instanceof BadRequestError || err instanceof AbortError) return null
+ const failure = toError(err)
+ console.error('Core: Command queue error', failure)
+ emitEvent(createErrorEvent(failure.message, TRANSFER_ERROR_CODES.transferFailed))
+ return null
+ }
- async function runCommand<T>(handler: () => Promise<T>): Promise<T> {
- const next = commandQueue.then(handler)
- commandQueue = next.catch((err: unknown) => {
- if (err instanceof BadRequestError || err instanceof AbortError) return null
- const failure = toError(err)
- console.error('Core: Command queue error', failure)
- emitEvent(createErrorEvent(failure.message, TRANSFER_ERROR_CODES.transferFailed))
- return null
- })
- return next
+ const downloads = new SerialQueue(reportFailure)
+ const commands = new SerialQueue(reportFailure)
+
+ function schedule<T>(method: TransferMethod, task: () => Promise<T>): Promise<T> {
+ if (runsWithoutWaiting(method)) return task()
+ return isFileTransfer(method) ? downloads.run(task) : commands.run(task)
+ }
+
+ function waitForDownloadsToStop(): Promise<unknown> {
+ return Promise.race([
+ downloads.whenIdle(),
+ new Promise((resolve) => setTimeout(resolve, DOWNLOAD_DRAIN_TIMEOUT_MS))
+ ])
}
const rpc = new RPC(stream, async (req: RPCRequest) => {
@@ -43,13 +63,17 @@ export function createTransferWorkerRPCServer(
return
}
- if (method === 'disconnect' || method === 'closePeers') abortInFlight()
+ if (method === 'disconnect' || method === 'closePeers') {
+ abortInFlight()
+ await waitForDownloadsToStop()
+ }
const args = decodeRPCPayload<unknown[]>(req.data) ?? []
const invoke = orchestrator[method] as (...a: unknown[]) => Promise<unknown>
+ const run = () => invoke.apply(orchestrator, args)
try {
- const reply = await runCommand(() => invoke.apply(orchestrator, args))
+ const reply = await schedule(method, run)
req.reply(encodeRPCSuccess(reply))
} catch (err: unknown) {
if (err instanceof BadRequestError) {
diff --git a/packages/core/src/worklet/transfer/control-channel.ts b/packages/core/src/worklet/transfer/control-channel.ts
index 92441b4..63af313 100644
--- a/packages/core/src/worklet/transfer/control-channel.ts
+++ b/packages/core/src/worklet/transfer/control-channel.ts
@@ -71,6 +71,7 @@ export interface DownloadFailed {
fileId: string
fileName: string
message: string
+ paused?: boolean
}
export interface PairingInfo {
diff --git a/packages/core/src/worklet/transfer/download-events.ts b/packages/core/src/worklet/transfer/download-events.ts
index a14de50..c092643 100644
--- a/packages/core/src/worklet/transfer/download-events.ts
+++ b/packages/core/src/worklet/transfer/download-events.ts
@@ -6,6 +6,17 @@ import type {
DownloadRequest
} from './control-channel'
import type { PeerSession } from './swarm'
+import type { DownloadFileRequest } from '../rpc/protocol'
+import { getFileName } from './utils'
+
+export interface DownloadFailureDetail {
+ resumable?: boolean
+ cancelled?: boolean
+}
+
+export type DownloadFileOutcome =
+ | { ok: true; savedTo: string }
+ | { ok: false; message: string; resumable?: boolean; cancelled?: boolean }
export interface DownloadLifecycleEvent {
transferId: string
@@ -16,6 +27,9 @@ export interface DownloadLifecycleEvent {
totalBytes: number
bytesTransferred?: number
message?: string
+ resumable?: boolean
+ cancelled?: boolean
+ pausable?: boolean
}
export interface DownloaderCallbacks {
@@ -35,12 +49,24 @@ export function getDownloadFailureMessage(event: DownloadLifecycleEvent): string
}
export function createDownloadStatusEvent(event: DownloadLifecycleEvent): Partial<StatusEvent> {
- const { transferId, fileId, totalBytes, bytesTransferred, message } = event
+ const {
+ transferId,
+ fileId,
+ totalBytes,
+ bytesTransferred,
+ message,
+ resumable,
+ cancelled,
+ pausable
+ } = event
return {
file: event.fileName,
path: event.sourcePath,
savedTo: event.targetPath,
+ resumable,
+ cancelled,
+ pausable,
transferId,
fileId,
totalBytes,
@@ -69,7 +95,8 @@ export function createPeerDownloadStatusEvent(
fileId: message.fileId,
totalBytes: 'totalBytes' in message ? message.totalBytes : undefined,
bytesTransferred: 'bytesTransferred' in message ? message.bytesTransferred : undefined,
- message: 'message' in message ? message.message : undefined
+ message: 'message' in message ? message.message : undefined,
+ paused: 'paused' in message ? message.paused : undefined
}
}
@@ -111,6 +138,59 @@ export function createDownloadFailedMessage(event: DownloadLifecycleEvent): Down
transferId: event.transferId,
fileId: event.fileId,
fileName: event.fileName,
- message: getDownloadFailureMessage(event)
+ message: getDownloadFailureMessage(event),
+ paused: event.cancelled === true
+ }
+}
+
+export interface DownloadReporterInit {
+ file: DownloadFileRequest
+ callbacks: DownloaderCallbacks
+ targetPath: string
+ totalBytes: number
+ pausable?: boolean
+}
+
+export class DownloadReporter {
+ private readonly callbacks: DownloaderCallbacks
+ private readonly targetPath: string
+ private readonly totalBytes: number
+ private readonly pausable: boolean
+ private readonly base: Omit<DownloadLifecycleEvent, 'bytesTransferred'>
+
+ constructor({ file, callbacks, targetPath, totalBytes, pausable = false }: DownloadReporterInit) {
+ this.callbacks = callbacks
+ this.targetPath = targetPath
+ this.totalBytes = totalBytes
+ this.pausable = pausable
+ this.base = {
+ transferId: file.transferId,
+ fileId: file.fileId,
+ fileName: file.name ?? getFileName(file.path),
+ sourcePath: file.path,
+ targetPath,
+ totalBytes
+ }
+ }
+
+ started(): void {
+ this.callbacks.onFileStart({ ...this.base, pausable: this.pausable, bytesTransferred: 0 })
+ }
+
+ progressed(bytesTransferred: number): void {
+ this.callbacks.onFileProgress({ ...this.base, bytesTransferred })
+ }
+
+ completed(savedTo: string = this.targetPath): void {
+ this.callbacks.onFileComplete({
+ ...this.base,
+ targetPath: savedTo,
+ bytesTransferred: this.totalBytes
+ })
+ }
+
+ failed(message: string, extra: DownloadFailureDetail = {}): DownloadFileOutcome {
+ this.callbacks.onFileError({ ...this.base, message, ...extra })
+ return { ok: false, message, ...extra }
}
}
diff --git a/packages/core/src/worklet/transfer/drive.test.ts b/packages/core/src/worklet/transfer/drive.test.ts
index 23544eb..034fbf1 100644
--- a/packages/core/src/worklet/transfer/drive.test.ts
+++ b/packages/core/src/worklet/transfer/drive.test.ts
@@ -28,6 +28,24 @@ function socketPair(): [PeerSocket, PeerSocket] {
]
}
+class MemoryWriter {
+ bytes = new Uint8Array(0)
+ constructor(private readonly savedTo: string) {}
+ async allocate(size: number) {
+ if (this.bytes.length !== size) this.bytes = new Uint8Array(size)
+ }
+ async write(offset: number, data: Uint8Array) {
+ this.bytes.set(data, offset)
+ }
+ async readBack(offset: number, length: number) {
+ return this.bytes.subarray(offset, offset + length)
+ }
+ async finalize() {
+ return this.savedTo
+ }
+ async abort() {}
+}
+
function payload(size: number): Uint8Array {
const bytes = new Uint8Array(size)
for (let i = 0; i < size; i++) bytes[i] = (i * 31 + 11) & 0xff
@@ -132,3 +150,58 @@ describe('PeerDrive', () => {
await expect(serving).rejects.toThrow('cancelled')
})
})
+
+describe('PeerDrive.serve supersession', () => {
+ it('serialises rapid repeat requests for the same file instead of running them together', async () => {
+ const [socketA, socketB] = socketPair()
+ const senderSide = PeerDrive.create(socketA)!
+ PeerDrive.create(socketB)!
+ await senderSide.supported
+
+ const [src] = await sourceFile('in.bin', 64 * 1024)
+
+ let concurrent = 0
+ let peak = 0
+ const original = senderSide.session.bind(senderSide)
+ senderSide.session = (fileId: string) => {
+ concurrent++
+ peak = Math.max(peak, concurrent)
+ const channel = original(fileId)
+ const close = channel.close.bind(channel)
+ channel.close = () => {
+ concurrent--
+ close()
+ }
+ return channel
+ }
+
+ const all = [
+ senderSide.serve('f', 'in.bin', src),
+ senderSide.serve('f', 'in.bin', src),
+ senderSide.serve('f', 'in.bin', src)
+ ]
+ senderSide.destroy()
+ await Promise.allSettled(all)
+
+ expect(peak).toBeLessThanOrEqual(1)
+ })
+
+ it('a superseded send does not cancel the peer session the resume just opened', async () => {
+ const [socketA, socketB] = socketPair()
+ const senderSide = PeerDrive.create(socketA)!
+ const receiverSide = PeerDrive.create(socketB)!
+ await senderSide.supported
+
+ const [src, input] = await sourceFile('in.bin', 300 * 1024)
+ const writer = new MemoryWriter('/saved/in.bin')
+
+ const receiver = new ReceiverSession(writer, receiverSide.session('f'), { transferId: 'f' })
+ const done = receiver.receive()
+
+ senderSide.serve('f', 'in.bin', src).catch((err) => console.error('first serve', err))
+ senderSide.serve('f', 'in.bin', src).catch((err) => console.error('second serve', err))
+
+ await expect(done).resolves.toBe('/saved/in.bin')
+ expect(Buffer.from(writer.bytes).equals(Buffer.from(input))).toBe(true)
+ })
+})
diff --git a/packages/core/src/worklet/transfer/drive.ts b/packages/core/src/worklet/transfer/drive.ts
index 224dbcd..bc0bf00 100644
--- a/packages/core/src/worklet/transfer/drive.ts
+++ b/packages/core/src/worklet/transfer/drive.ts
@@ -18,20 +18,17 @@ const chunkEncoding: Encoding<ChunkFrame> = {
preencode(state, frame) {
c.string.preencode(state, frame.transferId)
c.uint.preencode(state, frame.index)
- c.string.preencode(state, frame.hash)
c.raw.preencode(state, frame.data)
},
encode(state, frame) {
c.string.encode(state, frame.transferId)
c.uint.encode(state, frame.index)
- c.string.encode(state, frame.hash)
c.raw.encode(state, frame.data)
},
decode(state) {
return {
transferId: c.string.decode(state),
index: c.uint.decode(state),
- hash: c.string.decode(state),
data: c.raw.decode(state)
}
}
@@ -40,16 +37,22 @@ const chunkEncoding: Encoding<ChunkFrame> = {
interface Session {
onMessage?: (message: ControlMessage) => void
onChunk?: (header: ChunkHeader, data: Uint8Array) => void
+ pendingCancel?: ControlMessage
}
type ProtomuxChannelLike = NonNullable<ReturnType<Protomux['createChannel']>>
+function cancelForDisconnect(transferId: string): ControlMessage {
+ return { type: 'cancel', transferId, reason: 'Peer disconnected' }
+}
+
export class PeerDrive {
private readonly channel: ProtomuxChannelLike
private readonly control: ProtomuxMessage<ControlMessage>
private readonly chunk: ProtomuxMessage<ChunkFrame>
private readonly sessions = new Map<string, Session>()
- private readonly sends = new Map<string, AbortController>()
+ private readonly sends = new Map<string, { abort: AbortController; done: Promise<void> }>()
+ private destroyed = false
readonly supported: Promise<boolean>
@@ -65,8 +68,8 @@ export class PeerDrive {
})
this.chunk = channel.addMessage<ChunkFrame>({
encoding: chunkEncoding,
- onmessage: ({ transferId, index, hash, data }) => {
- this.sessions.get(transferId)?.onChunk?.({ transferId, index, hash }, data)
+ onmessage: ({ transferId, index, data }) => {
+ this.sessions.get(transferId)?.onChunk?.({ transferId, index }, data)
}
})
channel.open()
@@ -80,13 +83,15 @@ export class PeerDrive {
session(fileId: string): DriveChannel {
const session: Session = {}
- this.sessions.set(fileId, session)
+ if (this.destroyed) session.pendingCancel = cancelForDisconnect(fileId)
+ else this.sessions.set(fileId, session)
return {
send: (message) => this.control.send(message),
sendChunk: (header, data) => this.chunk.send({ ...header, data }),
onMessage: (handler) => {
session.onMessage = handler
+ if (session.pendingCancel) handler(session.pendingCancel)
},
onChunk: (handler) => {
session.onChunk = handler
@@ -99,10 +104,19 @@ export class PeerDrive {
}
async serve(fileId: string, name: string, localPath: string | null): Promise<void> {
- if (this.sends.has(fileId)) return
+ const previous = this.sends.get(fileId)
const abort = new AbortController()
+ let settle!: () => void
+ const done = new Promise<void>((resolve) => {
+ settle = resolve
+ })
+ this.sends.set(fileId, { abort, done })
+
+ if (previous) {
+ previous.abort.abort()
+ await previous.done
+ }
- this.sends.set(fileId, abort)
let channel: DriveChannel | null = null
try {
@@ -120,22 +134,27 @@ export class PeerDrive {
await sendFile(localPath, channel, {
transferId: fileId,
name,
- signal: abort.signal
+ signal: abort.signal,
+ notifyPeerOnCancel: false
})
} finally {
channel?.close()
- this.sends.delete(fileId)
+ if (this.sends.get(fileId)?.abort === abort) this.sends.delete(fileId)
+ settle()
}
}
cancel(): void {
- for (const abort of this.sends.values()) abort.abort()
+ for (const entry of this.sends.values()) entry.abort.abort()
}
destroy(): void {
+ this.destroyed = true
this.cancel()
for (const [transferId, session] of this.sessions) {
- session.onMessage?.({ type: 'cancel', transferId, reason: 'Peer disconnected' })
+ const cancel = cancelForDisconnect(transferId)
+ if (session.onMessage) session.onMessage(cancel)
+ else session.pendingCancel = cancel
}
this.sessions.clear()
diff --git a/packages/core/src/worklet/transfer/fs-utils.ts b/packages/core/src/worklet/transfer/fs-utils.ts
new file mode 100644
index 0000000..abaabc7
--- /dev/null
+++ b/packages/core/src/worklet/transfer/fs-utils.ts
@@ -0,0 +1,9 @@
+import fs from 'bare-fs'
+
+export function fileExists(filePath: string): Promise<boolean> {
+ return new Promise((resolve) => {
+ ;(fs as unknown as { stat(p: string, cb: (e: unknown) => void): void }).stat(filePath, (err) =>
+ resolve(!err)
+ )
+ })
+}
diff --git a/packages/core/src/worklet/transfer/legacy/downloader.ts b/packages/core/src/worklet/transfer/legacy/downloader.ts
new file mode 100644
index 0000000..e9a1226
--- /dev/null
+++ b/packages/core/src/worklet/transfer/legacy/downloader.ts
@@ -0,0 +1,218 @@
+import Hyperdrive from 'hyperdrive'
+import type Corestore from 'corestore'
+import b4a from 'b4a'
+import fs from 'bare-fs'
+import { firstFreePath } from '@altersend/drive'
+import {
+ AbortError,
+ type AbortLike,
+ getChunkSize,
+ getDirname,
+ getFileName,
+ isValidHexKey,
+ onAbort
+} from '../utils'
+import { fileExists } from '../fs-utils'
+import {
+ DownloadReporter,
+ type DownloaderCallbacks,
+ type DownloadFileOutcome
+} from '../download-events'
+import type { DownloadFileRequest } from '../../rpc/protocol'
+
+export class LegacyHyperdriveDownloader {
+ private readonly driveStore: Corestore
+ private readonly remoteDrives = new Map<string, Hyperdrive>()
+
+ constructor(driveStore: Corestore) {
+ this.driveStore = driveStore
+ }
+
+ async download(
+ file: DownloadFileRequest,
+ targetPath: string,
+ callbacks: DownloaderCallbacks,
+ signal?: AbortLike
+ ): Promise<DownloadFileOutcome> {
+ const remoteDrive = await this.getRemoteDrive(file.driveKey)
+ const resolvedName = file.name ?? getFileName(file.path)
+ const announced = new DownloadReporter({
+ file,
+ callbacks,
+ targetPath,
+ totalBytes: file.size ?? 0
+ })
+
+ const entry = await remoteDrive.entry(file.path)
+ if (!entry?.value?.blob) {
+ return announced.failed(`Could not find remote file: ${resolvedName}`)
+ }
+
+ const actualBytes = entry.value.blob.byteLength
+ if (typeof file.size === 'number' && file.size !== actualBytes) {
+ return announced.failed(`Sender claimed ${file.size} bytes but file is ${actualBytes} bytes`)
+ }
+
+ const events = new DownloadReporter({
+ file,
+ callbacks,
+ targetPath,
+ totalBytes: actualBytes
+ })
+ events.started()
+
+ const savedTo = await this.writeToDisk(
+ remoteDrive,
+ file.path,
+ targetPath,
+ actualBytes,
+ (bytesTransferred) => events.progressed(bytesTransferred),
+ signal,
+ file.overwrite === true
+ )
+
+ events.completed(savedTo)
+ return { ok: true, savedTo }
+ }
+
+ async evictDrive(driveKey: string): Promise<void> {
+ const cached = this.remoteDrives.get(driveKey)
+ if (!cached) return
+ this.remoteDrives.delete(driveKey)
+ try {
+ await cached.close()
+ } catch (err) {
+ console.warn('LegacyHyperdrive: failed to close evicted drive', err)
+ }
+ }
+
+ async closeAll(): Promise<void> {
+ const drives = Array.from(this.remoteDrives.values())
+ this.remoteDrives.clear()
+ for (const drive of drives) {
+ try {
+ await drive.close()
+ } catch (err) {
+ console.warn('LegacyHyperdrive: close drive failed', err)
+ }
+ }
+ }
+
+ private async getRemoteDrive(driveKey: string): Promise<Hyperdrive> {
+ if (!isValidHexKey(driveKey)) {
+ throw new Error(`Invalid drive key format: expected 64 hex chars`)
+ }
+ const existingDrive = this.remoteDrives.get(driveKey)
+ if (existingDrive) {
+ try {
+ await existingDrive.update({ wait: true })
+ } catch (err) {
+ console.warn('LegacyHyperdrive: update on cached drive failed, using cached state', err)
+ }
+ return existingDrive
+ }
+
+ const remoteDrive = new Hyperdrive(this.driveStore, b4a.from(driveKey, 'hex'))
+ await remoteDrive.ready()
+ try {
+ await remoteDrive.update({ wait: true })
+ } catch (err) {
+ try {
+ await remoteDrive.close()
+ } catch {}
+ throw new Error(
+ `Could not sync with peer drive: ${err instanceof Error ? err.message : String(err)}`
+ )
+ }
+ this.remoteDrives.set(driveKey, remoteDrive)
+ return remoteDrive
+ }
+
+ private freeTargetPath(targetPath: string): Promise<string> {
+ return firstFreePath(targetPath, async (candidate) => !(await fileExists(candidate)))
+ }
+
+ private async writeToDisk(
+ remoteDrive: Hyperdrive,
+ sourcePath: string,
+ targetPath: string,
+ totalBytes: number,
+ onProgress: (bytesTransferred: number) => void,
+ signal?: AbortLike,
+ overwrite = false
+ ): Promise<string> {
+ const { default: Localdrive } = await import('localdrive')
+ const destination = new Localdrive(getDirname(targetPath))
+ const partName = `${getFileName(targetPath)}.part`
+ const partPath = `${targetPath}.part`
+
+ const readStream = remoteDrive.createReadStream(sourcePath)
+ const writeStream = destination.createWriteStream(`/${partName}`)
+
+ let release = () => {}
+
+ try {
+ await new Promise<void>((resolve, reject) => {
+ let settled = false
+ let bytesTransferred = 0
+ let lastReportedBytes = 0
+
+ const destroyStreams = () => {
+ try {
+ readStream.destroy()
+ } catch {}
+ try {
+ writeStream.destroy()
+ } catch {}
+ }
+
+ const finish = (err?: Error) => {
+ if (settled) return
+ settled = true
+ if (!err) {
+ resolve()
+ return
+ }
+ destroyStreams()
+ reject(err)
+ }
+
+ release = onAbort(signal, () => finish(new AbortError()))
+
+ readStream.on('data', (chunk: unknown) => {
+ bytesTransferred += getChunkSize(chunk)
+ const nextBytes =
+ totalBytes > 0 ? Math.min(bytesTransferred, totalBytes) : bytesTransferred
+ if (nextBytes === totalBytes || nextBytes - lastReportedBytes >= 64 * 1024) {
+ lastReportedBytes = nextBytes
+ onProgress(nextBytes)
+ }
+ })
+ readStream.once('error', finish)
+ writeStream.once('error', finish)
+ writeStream.once('close', () => {
+ if (totalBytes > 0 && lastReportedBytes < totalBytes) {
+ onProgress(totalBytes)
+ }
+ finish()
+ })
+ readStream.pipe(writeStream)
+ })
+ } catch (err) {
+ try {
+ await fs.promises.unlink(partPath)
+ } catch (cleanupErr) {
+ if ((cleanupErr as NodeJS.ErrnoException)?.code !== 'ENOENT') {
+ console.warn('LegacyHyperdrive: failed to delete partial file', partPath, cleanupErr)
+ }
+ }
+ throw err
+ } finally {
+ release()
+ }
+
+ const finalPath = overwrite ? targetPath : await this.freeTargetPath(targetPath)
+ await fs.promises.rename(partPath, finalPath)
+ return finalPath
+ }
+}
diff --git a/packages/core/src/worklet/transfer/legacy/staging.ts b/packages/core/src/worklet/transfer/legacy/staging.ts
new file mode 100644
index 0000000..5d81f22
--- /dev/null
+++ b/packages/core/src/worklet/transfer/legacy/staging.ts
@@ -0,0 +1,80 @@
+import type Hyperdrive from 'hyperdrive'
+import type Localdrive from 'localdrive'
+import MirrorDrive from 'mirror-drive'
+import b4a from 'b4a'
+import { AbortError } from '../utils'
+import type { ScannedFile } from '../sender'
+
+export class LegacyPeerStaging {
+ private readonly drive: Hyperdrive
+ private pending: ScannedFile[] = []
+ private running: Promise<void> | null = null
+
+ constructor(drive: Hyperdrive) {
+ this.drive = drive
+ }
+
+ get driveKey(): string {
+ return b4a.toString(this.drive.key, 'hex')
+ }
+
+ stagedEntry(sourcePath: string) {
+ return this.drive.entry(sourcePath)
+ }
+
+ setPendingFiles(files: ScannedFile[]): void {
+ this.pending = files
+ }
+
+ stage(
+ onStaging: (file: ScannedFile) => void,
+ onDrained: () => Promise<void>,
+ signal?: AbortSignal
+ ): Promise<void> {
+ if (!this.running) {
+ const run: Promise<void> = this.run(onStaging, onDrained, signal).catch((err) => {
+ if (this.running === run) this.running = null
+ throw err
+ })
+ this.running = run
+ }
+ return this.running
+ }
+
+ reset(): void {
+ this.pending = []
+ this.running = null
+ }
+
+ private async run(
+ onStaging: (file: ScannedFile) => void,
+ onDrained: () => Promise<void>,
+ signal?: AbortSignal
+ ): Promise<void> {
+ const files = this.pending
+ const superseded = () => this.pending !== files
+
+ try {
+ for (const file of files) {
+ if (signal?.aborted) throw new AbortError()
+ onStaging(file)
+ if (!file.alreadyStaged) await this.importToDrive(file.sourceDrive, file.sourcePath)
+ }
+ } catch (err) {
+ if (superseded()) return
+ throw err
+ }
+
+ if (superseded()) return
+ this.pending = []
+ await onDrained()
+ }
+
+ private async importToDrive(sourceDrive: Localdrive, sourcePath: string): Promise<void> {
+ const mirror = new MirrorDrive(sourceDrive, this.drive, {
+ entries: [sourcePath],
+ prune: false
+ })
+ await mirror.done()
+ }
+}
diff --git a/packages/core/src/worklet/transfer/orchestrator.ts b/packages/core/src/worklet/transfer/orchestrator.ts
index fcd77f6..6b084e5 100644
--- a/packages/core/src/worklet/transfer/orchestrator.ts
+++ b/packages/core/src/worklet/transfer/orchestrator.ts
@@ -96,7 +96,7 @@ export class TransferOrchestrator implements TransferRPC {
private role: TransferRole | null = null
private currentTopic: string | null = null
private suspended: boolean = false
- private inflightAbort: AbortController | null = null
+ private readonly inflight = new Set<AbortController>()
private stagingAbort: AbortController | null = null
private readonly deviceIdentityStore: DeviceIdentityStore
@@ -292,7 +292,13 @@ export class TransferOrchestrator implements TransferRPC {
if (!session.drive) return
session.drive
.serve(message.fileId, message.fileName, this.storage.sender.localPath(message.fileId))
- .catch((err) => console.warn('TransferOrchestrator: drive send failed', err))
+ .catch((err) =>
+ console.warn(
+ 'TransferOrchestrator: drive send stopped',
+ message.fileName,
+ err instanceof Error ? err.message : String(err)
+ )
+ )
}
private async driveChannelFor(file: DownloadFileRequest): Promise<DriveChannel | null> {
@@ -354,7 +360,9 @@ export class TransferOrchestrator implements TransferRPC {
message
})
this.swarm.broadcast(createDownloadFailedMessage({ ...event, message }))
- this.sendError(message, TRANSFER_ERROR_CODES.downloadFailed)
+ if (!event.resumable && !event.cancelled) {
+ this.sendError(message, TRANSFER_ERROR_CODES.downloadFailed)
+ }
}
private getDownloaderCallbacks(): DownloaderCallbacks {
@@ -476,7 +484,7 @@ export class TransferOrchestrator implements TransferRPC {
const ready = this.activeTransferReady
if (!ready) return
- this.prepareFor(session)
+ this.stageForLegacyPeer(session)
.then(() => {
if (this.activeTransferReady !== ready) return
session.controlChannel.send(ready)
@@ -488,7 +496,7 @@ export class TransferOrchestrator implements TransferRPC {
})
}
- private async prepareFor(session: PeerSession): Promise<void> {
+ private async stageForLegacyPeer(session: PeerSession): Promise<void> {
if (await this.speaksDrive(session.drive)) return
const transferId = this.activeTransferReady?.transferId
@@ -511,7 +519,7 @@ export class TransferOrchestrator implements TransferRPC {
}
const controller = new AbortController()
- this.inflightAbort = controller
+ this.inflight.add(controller)
try {
const results = await this.storage.receiver.downloadFiles(
files,
@@ -521,7 +529,19 @@ export class TransferOrchestrator implements TransferRPC {
)
return { files: results }
} finally {
- this.inflightAbort = null
+ this.inflight.delete(controller)
+ }
+ }
+
+ async pauseDownload(fileId: string): Promise<void> {
+ if (typeof fileId !== 'string' || fileId.length === 0) {
+ throw new BadRequestError('Missing fileId')
+ }
+ const active = this.storage.receiver.activeDownloadIds()
+ if (!this.storage.receiver.pause(fileId)) {
+ throw new BadRequestError(
+ `pauseDownload: no active download for "${fileId}". Active: [${active.join(', ')}]`
+ )
}
}
@@ -530,11 +550,7 @@ export class TransferOrchestrator implements TransferRPC {
this.stagingAbort?.abort()
this.stagingAbort = null
- const controller = this.inflightAbort
- if (!controller) return
-
- this.inflightAbort = null
- controller.abort()
+ for (const controller of this.inflight) controller.abort()
}
async disconnect(): Promise<DisconnectReply> {
@@ -568,6 +584,7 @@ export class TransferOrchestrator implements TransferRPC {
this.currentTopic = null
this.offerPeers.clear()
await this.swarm.endSession()
+ await this.storage.receiver.discardPartials()
}
async setRelayConfig(input: SetRelayConfigInput): Promise<SetRelayConfigReply> {
diff --git a/packages/core/src/worklet/transfer/receiver.ts b/packages/core/src/worklet/transfer/receiver.ts
index d6c5d3f..77f9b85 100644
--- a/packages/core/src/worklet/transfer/receiver.ts
+++ b/packages/core/src/worklet/transfer/receiver.ts
@@ -1,88 +1,81 @@
-import Hyperdrive from 'hyperdrive'
import type Corestore from 'corestore'
-import b4a from 'b4a'
-import fs from 'bare-fs'
-import { receiveFile, type DriveChannel } from '@altersend/drive'
import {
- AbortError,
+ receiveFile,
+ discardPartial,
+ firstFreePath,
+ type Bitmap,
+ type DriveChannel
+} from '@altersend/drive'
+import {
+ type AbortLike,
getDirname,
getFileName,
isPathSafe,
isSafeRelativePath,
- isValidHexKey,
joinFilePath,
onAbort,
toRelativePath
} from './utils'
+import { fileExists } from './fs-utils'
+import { LegacyHyperdriveDownloader } from './legacy/downloader'
import type { DownloadFileRequest, DownloadFileResult } from '../rpc/protocol'
-import type { DownloaderCallbacks } from './download-events'
-
-type DownloadFileOutcome = { ok: true; savedTo: string } | { ok: false; message: string }
-
-function fileEvents(
- file: DownloadFileRequest,
- callbacks: DownloaderCallbacks,
- targetPath: string,
- totalBytes: number
-) {
- const base = {
- transferId: file.transferId,
- fileId: file.fileId,
- fileName: file.name ?? getFileName(file.path),
- sourcePath: file.path,
- targetPath,
- totalBytes
- }
- return {
- started: () => callbacks.onFileStart({ ...base, bytesTransferred: 0 }),
- progressed: (bytesTransferred: number) =>
- callbacks.onFileProgress({ ...base, bytesTransferred }),
- completed: () => callbacks.onFileComplete({ ...base, bytesTransferred: totalBytes }),
- failed: (message: string): DownloadFileOutcome => {
- callbacks.onFileError({ ...base, message })
- return { ok: false, message }
- }
- }
+import {
+ DownloadReporter,
+ type DownloaderCallbacks,
+ type DownloadFileOutcome
+} from './download-events'
+
+interface PartialDownload {
+ finalPath: string
+ bitmap?: Bitmap
+ received: number
+ overwrite?: boolean
}
-function getChunkSize(chunk: unknown): number {
- if (typeof chunk === 'string') return Buffer.byteLength(chunk)
- if (
- chunk &&
- typeof chunk === 'object' &&
- 'byteLength' in chunk &&
- typeof (chunk as { byteLength: unknown }).byteLength === 'number'
- ) {
- return (chunk as { byteLength: number }).byteLength
- }
- return 0
+function toMessage(error: unknown): string {
+ return error instanceof Error ? error.message : String(error)
}
export class TransferReceiver {
- private readonly driveStore: Corestore
- private readonly remoteDrives: Map<string, Hyperdrive>
+ private readonly legacy: LegacyHyperdriveDownloader
+ private readonly partials = new Map<string, PartialDownload>()
+ private readonly active = new Map<string, AbortController>()
+ private readonly queued = new Set<string>()
+ private readonly paused = new Set<string>()
constructor(driveStore: Corestore) {
- this.driveStore = driveStore
- this.remoteDrives = new Map()
+ this.legacy = new LegacyHyperdriveDownloader(driveStore)
}
async downloadFiles(
files: DownloadFileRequest[],
callbacks: DownloaderCallbacks,
- signal?: AbortSignal,
+ signal?: AbortLike,
driveFor?: (file: DownloadFileRequest) => Promise<DriveChannel | null>
): Promise<DownloadFileResult[]> {
const results: DownloadFileResult[] = []
+ for (const file of files) {
+ this.paused.delete(file.fileId)
+ this.queued.add(file.fileId)
+ }
for (const file of files) {
+ this.queued.delete(file.fileId)
const resolvedName = file.name ?? getFileName(file.path)
const record = (outcome: DownloadFileOutcome) =>
results.push({ fileId: file.fileId, fileName: resolvedName, ...outcome })
const fail = (targetPath: string, message: string) =>
- record(fileEvents(file, callbacks, targetPath, file.size ?? 0).failed(message))
+ record(
+ new DownloadReporter({
+ file,
+ callbacks,
+ targetPath,
+ totalBytes: file.size ?? 0
+ }).failed(message)
+ )
- if (signal?.aborted) {
+ if (signal?.aborted || this.paused.has(file.fileId)) {
+ this.paused.delete(file.fileId)
results.push({
fileId: file.fileId,
fileName: resolvedName,
@@ -106,247 +99,165 @@ export class TransferReceiver {
const targetPath = file.targetPath ?? joinFilePath(file.targetDir!, relativeTarget)
+ if (this.active.has(file.fileId)) {
+ fail(targetPath, 'Already downloading this file')
+ continue
+ }
+
+ const perFile = new AbortController()
+ this.active.set(file.fileId, perFile)
+ const releaseOuter = onAbort(signal, () => perFile.abort())
+
try {
const channel = (await driveFor?.(file)) ?? null
record(
channel
- ? await this.downloadViaDrive(file, targetPath, callbacks, channel, signal)
- : await this.downloadFile(file, targetPath, callbacks, signal)
+ ? await this.downloadViaDrive(file, targetPath, callbacks, channel, perFile.signal)
+ : await this.legacy.download(file, targetPath, callbacks, perFile.signal)
)
} catch (error) {
- await this.evictRemoteDrive(file.driveKey)
+ const cancelled = error instanceof Error && error.name === 'AbortError'
+ if (!cancelled) await this.legacy.evictDrive(file.driveKey)
- fail(targetPath, error instanceof Error ? error.message : String(error))
+ record(
+ new DownloadReporter({
+ file,
+ callbacks,
+ targetPath,
+ totalBytes: file.size ?? 0
+ }).failed(cancelled ? 'Cancelled' : toMessage(error), { cancelled })
+ )
+ } finally {
+ releaseOuter()
+ this.active.delete(file.fileId)
}
}
+ for (const file of files) this.queued.delete(file.fileId)
return results
}
- private async downloadFile(
- file: DownloadFileRequest,
- targetPath: string,
- callbacks: DownloaderCallbacks,
- signal?: AbortSignal
- ): Promise<DownloadFileOutcome> {
- const remoteDrive = await this.getRemoteDrive(file.driveKey)
- const resolvedName = file.name ?? getFileName(file.path)
- const announced = fileEvents(file, callbacks, targetPath, file.size ?? 0)
-
- const entry = await remoteDrive.entry(file.path)
- if (!entry?.value?.blob) {
- return announced.failed(`Could not find remote file: ${resolvedName}`)
- }
-
- const actualBytes = entry.value.blob.byteLength
- if (typeof file.size === 'number' && file.size !== actualBytes) {
- return announced.failed(`Sender claimed ${file.size} bytes but file is ${actualBytes} bytes`)
- }
-
- const events = fileEvents(file, callbacks, targetPath, actualBytes)
- events.started()
-
- const savedTo = await this.writeToDisk(
- remoteDrive,
- file.path,
- targetPath,
- actualBytes,
- (bytesTransferred) => events.progressed(bytesTransferred),
- signal
- )
-
- events.completed()
- return { ok: true, savedTo }
- }
-
private async downloadViaDrive(
file: DownloadFileRequest,
targetPath: string,
callbacks: DownloaderCallbacks,
channel: DriveChannel,
- signal?: AbortSignal
+ signal?: AbortLike
): Promise<DownloadFileOutcome> {
+ const partial = await this.findResumablePartial(file.fileId, targetPath)
try {
- const finalPath = await this.findUniqueTargetPath(targetPath)
- const events = fileEvents(file, callbacks, finalPath, file.size ?? 0)
+ const overwrite = partial ? partial.overwrite === true : file.overwrite === true
+ const finalPath =
+ partial?.finalPath ?? (overwrite ? targetPath : await this.availableTargetPath(targetPath))
+ const events = new DownloadReporter({
+ file,
+ callbacks,
+ targetPath: finalPath,
+ totalBytes: file.size ?? 0,
+ pausable: true
+ })
+ const progress: PartialDownload = {
+ finalPath,
+ bitmap: partial?.bitmap,
+ received: partial?.received ?? 0,
+ overwrite
+ }
+ this.partials.set(file.fileId, progress)
const pending = receiveFile(finalPath, channel, {
transferId: file.fileId,
expectedSize: file.size,
signal,
- onProgress: (bytesTransferred) => events.progressed(bytesTransferred)
+ overwrite,
+ resumeBits: partial?.bitmap?.serialize(),
+ onProgress: (bytesTransferred) => events.progressed(bytesTransferred),
+ onChunkWritten: (bitmap) => {
+ progress.bitmap = bitmap
+ progress.received = bitmap.count()
+ }
})
events.started()
try {
- await pending
- events.completed()
- return { ok: true, savedTo: finalPath }
+ const savedTo = await pending
+ this.partials.delete(file.fileId)
+ events.completed(savedTo)
+ return { ok: true, savedTo }
} catch (err) {
- return events.failed(err instanceof Error ? err.message : String(err))
+ const corrupt = err instanceof Error && err.name === 'IntegrityError'
+ if (corrupt) await this.discardPartials([file.fileId])
+ return events.failed(toMessage(err), {
+ resumable: !corrupt && (this.partials.get(file.fileId)?.received ?? 0) > 0,
+ cancelled: this.paused.delete(file.fileId)
+ })
}
} finally {
channel.close()
}
}
- private async evictRemoteDrive(driveKey: string): Promise<void> {
- const cached = this.remoteDrives.get(driveKey)
- if (!cached) return
- this.remoteDrives.delete(driveKey)
- try {
- await cached.close()
- } catch (err) {
- console.warn('TransferReceiver: failed to close evicted drive', err)
+ private async findResumablePartial(
+ fileId: string,
+ targetPath: string
+ ): Promise<PartialDownload | null> {
+ const partial = this.partials.get(fileId)
+ if (!partial) return null
+ const stale =
+ partial.received === 0 ||
+ getDirname(partial.finalPath) !== getDirname(targetPath) ||
+ !(await fileExists(`${partial.finalPath}.part`))
+ if (stale) {
+ await this.discardPartials([fileId])
+ return null
}
+ return partial
}
- private async getRemoteDrive(driveKey: string): Promise<Hyperdrive> {
- if (!isValidHexKey(driveKey)) {
- throw new Error(`Invalid drive key format: expected 64 hex chars`)
- }
- const existingDrive = this.remoteDrives.get(driveKey)
- if (existingDrive) {
- try {
- await existingDrive.update({ wait: true })
- } catch (err) {
- console.warn('TransferReceiver: update on cached drive failed, using cached state', err)
- }
- return existingDrive
+ activeDownloadIds(): string[] {
+ return Array.from(this.active.keys())
+ }
+
+ pause(fileId: string): boolean {
+ const controller = this.active.get(fileId)
+ if (controller) {
+ this.paused.add(fileId)
+ controller.abort()
+ return true
}
+ if (!this.queued.has(fileId)) return false
+ this.paused.add(fileId)
+ return true
+ }
- const remoteDrive = new Hyperdrive(this.driveStore, b4a.from(driveKey, 'hex'))
- await remoteDrive.ready()
- try {
- await remoteDrive.update({ wait: true })
- } catch (err) {
- try {
- await remoteDrive.close()
- } catch {}
- throw new Error(
- `Could not sync with peer drive: ${err instanceof Error ? err.message : String(err)}`
- )
+ async discardPartials(fileIds?: string[]): Promise<void> {
+ const ids = fileIds ?? Array.from(this.partials.keys())
+ for (const id of ids) {
+ const partial = this.partials.get(id)
+ if (!partial) continue
+ this.partials.delete(id)
+ await discardPartial(partial.finalPath)
}
- this.remoteDrives.set(driveKey, remoteDrive)
- return remoteDrive
}
async reset(): Promise<void> {
- const drives = Array.from(this.remoteDrives.values())
- this.remoteDrives.clear()
- for (const drive of drives) {
- try {
- await drive.close()
- } catch (err) {
- console.warn('TransferReceiver: close drive failed', err)
- }
- }
+ this.queued.clear()
+ this.paused.clear()
+ await this.discardPartials()
+ await this.legacy.closeAll()
}
async destroy(): Promise<void> {
await this.reset()
}
- private fileExists(filePath: string): Promise<boolean> {
- return new Promise((resolve) => {
- // bare-fs.promises lacks stat; the callback form is always present.
- ;(fs as unknown as { stat(p: string, cb: (e: unknown) => void): void }).stat(
- filePath,
- (err) => resolve(!err)
- )
- })
- }
-
- private async findUniqueTargetPath(targetPath: string): Promise<string> {
- if (!(await this.fileExists(targetPath))) return targetPath
- const dir = getDirname(targetPath)
- const filename = getFileName(targetPath)
- const dotIdx = filename.lastIndexOf('.')
- const base = dotIdx > 0 ? filename.slice(0, dotIdx) : filename
- const ext = dotIdx > 0 ? filename.slice(dotIdx) : ''
- for (let i = 1; i <= 999; i++) {
- const candidate = joinFilePath(dir, `${base} (${i})${ext}`)
- if (!(await this.fileExists(candidate))) return candidate
+ private isTargetInUse(targetPath: string): boolean {
+ for (const partial of this.partials.values()) {
+ if (partial.finalPath === targetPath) return true
}
- return targetPath
+ return false
}
- private async writeToDisk(
- remoteDrive: Hyperdrive,
- sourcePath: string,
- targetPath: string,
- totalBytes: number,
- onProgress: (bytesTransferred: number) => void,
- signal?: AbortSignal
- ): Promise<string> {
- const { default: Localdrive } = await import('localdrive')
- const destination = new Localdrive(getDirname(targetPath))
- const partName = `${getFileName(targetPath)}.part`
- const partPath = `${targetPath}.part`
-
- const readStream = remoteDrive.createReadStream(sourcePath)
- const writeStream = destination.createWriteStream(`/${partName}`)
-
- let release = () => {}
-
- try {
- await new Promise<void>((resolve, reject) => {
- let settled = false
- let bytesTransferred = 0
- let lastReportedBytes = 0
-
- const finish = (err?: Error) => {
- if (settled) return
- settled = true
- if (err) reject(err)
- else resolve()
- }
-
- // Settle before destroying streams so the outer catch sees AbortError, not stream-destroyed.
- release = onAbort(signal, () => {
- finish(new AbortError())
- try {
- readStream.destroy()
- } catch {}
- try {
- writeStream.destroy()
- } catch {}
- })
-
- readStream.on('data', (chunk: unknown) => {
- bytesTransferred += getChunkSize(chunk)
- const nextBytes =
- totalBytes > 0 ? Math.min(bytesTransferred, totalBytes) : bytesTransferred
- if (nextBytes === totalBytes || nextBytes - lastReportedBytes >= 64 * 1024) {
- lastReportedBytes = nextBytes
- onProgress(nextBytes)
- }
- })
- readStream.once('error', finish)
- writeStream.once('error', finish)
- writeStream.once('close', () => {
- if (totalBytes > 0 && lastReportedBytes < totalBytes) {
- onProgress(totalBytes)
- }
- finish()
- })
- readStream.pipe(writeStream)
- })
- } catch (err) {
- try {
- await fs.promises.unlink(partPath)
- } catch (cleanupErr) {
- if ((cleanupErr as NodeJS.ErrnoException)?.code !== 'ENOENT') {
- console.warn('TransferReceiver: failed to delete partial file', partPath, cleanupErr)
- }
- }
- throw err
- } finally {
- release()
- }
-
- const finalPath = await this.findUniqueTargetPath(targetPath)
- await fs.promises.rename(partPath, finalPath)
- return finalPath
+ private availableTargetPath(targetPath: string): Promise<string> {
+ return firstFreePath(targetPath, (candidate) => !this.isTargetInUse(candidate))
}
}
diff --git a/packages/core/src/worklet/transfer/resume.test.ts b/packages/core/src/worklet/transfer/resume.test.ts
new file mode 100644
index 0000000..2b1faba
--- /dev/null
+++ b/packages/core/src/worklet/transfer/resume.test.ts
@@ -0,0 +1,305 @@
+import { describe, it, expect, afterEach } from 'vitest'
+import { mkdtemp, writeFile, readFile, rm, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import SecretStream from '@hyperswarm/secret-stream'
+import { Duplex } from 'streamx'
+import type Corestore from 'corestore'
+import type { PeerSocket } from 'hyperswarm'
+import { PeerDrive } from './drive'
+import { TransferReceiver } from './receiver'
+import type { DownloaderCallbacks, DownloadLifecycleEvent } from './download-events'
+import type { DownloadFileRequest } from '../rpc/protocol'
+
+function socketPair(): [PeerSocket, PeerSocket] {
+ const a = new Duplex({
+ write(data: Uint8Array, cb: () => void) {
+ b.push(data)
+ cb()
+ }
+ })
+ const b = new Duplex({
+ write(data: Uint8Array, cb: () => void) {
+ a.push(data)
+ cb()
+ }
+ })
+ return [
+ new SecretStream(true, a) as unknown as PeerSocket,
+ new SecretStream(false, b) as unknown as PeerSocket
+ ]
+}
+
+function unusableStore(): Corestore {
+ return new Proxy(
+ {},
+ {
+ get(_target, prop) {
+ throw new Error(`Corestore.${String(prop)} was used on a drive-only transfer`)
+ }
+ }
+ ) as unknown as Corestore
+}
+
+function collect(): { callbacks: DownloaderCallbacks; errors: DownloadLifecycleEvent[] } {
+ const errors: DownloadLifecycleEvent[] = []
+ return {
+ errors,
+ callbacks: {
+ onFileStart: () => {},
+ onFileProgress: () => {},
+ onFileComplete: () => {},
+ onFileError: (event) => errors.push(event)
+ }
+ }
+}
+
+let dir = ''
+
+afterEach(async () => {
+ if (dir) await rm(dir, { recursive: true, force: true })
+ dir = ''
+})
+
+describe('drive resume through TransferReceiver', () => {
+ it('resumes a dropped download and sends only the missing chunks', async () => {
+ dir = await mkdtemp(join(tmpdir(), 'core-resume-'))
+ const src = join(dir, 'in.bin')
+ const input = new Uint8Array(8 * 1024 * 1024)
+ for (let i = 0; i < input.length; i++) input[i] = (i * 31 + 11) & 0xff
+ await writeFile(src, input)
+
+ const request: DownloadFileRequest = {
+ transferId: 't1',
+ fileId: 'f1',
+ driveKey: 'a'.repeat(64),
+ path: '/in.bin',
+ name: 'in.bin',
+ size: input.length,
+ targetPath: join(dir, 'out.bin')
+ }
+
+ const receiver = new TransferReceiver(unusableStore())
+
+ const attempt = async (abortAfterFirstChunk: boolean) => {
+ const [socketA, socketB] = socketPair()
+ const senderSide = PeerDrive.create(socketA)!
+ const receiverSide = PeerDrive.create(socketB)!
+ await senderSide.supported
+
+ const controller = new AbortController()
+ const { callbacks, errors } = collect()
+ let receivedBytes = 0
+ callbacks.onFileStart = () => {
+ senderSide
+ .serve(request.fileId, 'in.bin', src)
+ .catch((err) => console.error('test setup failed', err))
+ }
+ callbacks.onFileProgress = (event) => {
+ receivedBytes = event.bytesTransferred ?? 0
+ if (abortAfterFirstChunk) controller.abort()
+ }
+
+ const [result] = await receiver.downloadFiles(
+ [request],
+ callbacks,
+ controller.signal,
+ async () => receiverSide.session(request.fileId)
+ )
+ return { result, errors, receivedBytes }
+ }
+
+ const dst = join(dir, 'out.bin')
+
+ const first = await attempt(true)
+ expect(first.result.ok).toBe(false)
+ expect(first.errors[0]?.resumable).toBe(true)
+ expect((await stat(`${dst}.part`)).size).toBe(input.length)
+ expect(first.receivedBytes).toBeGreaterThan(0)
+ expect(first.receivedBytes).toBeLessThan(input.length)
+
+ const second = await attempt(false)
+ expect(second.result.ok).toBe(true)
+ expect(second.receivedBytes).toBe(input.length)
+ expect(Buffer.from(await readFile(dst)).equals(Buffer.from(input))).toBe(true)
+ await expect(stat(`${dst}.part`)).rejects.toThrow()
+ })
+})
+
+describe('pausing one download', () => {
+ it('stops the file mid-flight, keeps it resumable, and finishes on resume', async () => {
+ dir = await mkdtemp(join(tmpdir(), 'core-pause-'))
+ const src = join(dir, 'in.bin')
+ const input = new Uint8Array(16 * 1024 * 1024)
+ for (let i = 0; i < input.length; i++) input[i] = (i * 17 + 5) & 0xff
+ await writeFile(src, input)
+
+ const dst = join(dir, 'out.bin')
+ const request: DownloadFileRequest = {
+ transferId: 't1',
+ fileId: 'f1',
+ driveKey: 'a'.repeat(64),
+ path: '/in.bin',
+ name: 'in.bin',
+ size: input.length,
+ targetPath: dst
+ }
+
+ const receiver = new TransferReceiver(unusableStore())
+
+ const run = async (pauseOnFirstChunk: boolean) => {
+ const [socketA, socketB] = socketPair()
+ const senderSide = PeerDrive.create(socketA)!
+ const receiverSide = PeerDrive.create(socketB)!
+ await senderSide.supported
+
+ const { callbacks, errors } = collect()
+ callbacks.onFileStart = () => {
+ senderSide
+ .serve(request.fileId, 'in.bin', src)
+ .catch((err) => console.error('test setup failed', err))
+ }
+ if (pauseOnFirstChunk) {
+ callbacks.onFileProgress = () => receiver.pause(request.fileId)
+ }
+
+ const [result] = await receiver.downloadFiles([request], callbacks, undefined, async () =>
+ receiverSide.session(request.fileId)
+ )
+ return { result, errors }
+ }
+
+ const paused = await run(true)
+ expect(paused.result.ok).toBe(false)
+ expect(paused.errors[0]?.resumable).toBe(true)
+ expect((await stat(`${dst}.part`)).size).toBe(input.length)
+ await expect(stat(dst)).rejects.toThrow()
+
+ const resumed = await run(false)
+ expect(resumed.result.ok).toBe(true)
+ expect(Buffer.from(await readFile(dst)).equals(Buffer.from(input))).toBe(true)
+ })
+})
+
+describe('command scheduling', () => {
+ it('lets pause run without waiting, and queues transfers separately', async () => {
+ const { runsWithoutWaiting, isFileTransfer } = await import('../rpc/server')
+
+ expect(runsWithoutWaiting('pauseDownload')).toBe(true)
+ expect(isFileTransfer('downloadFiles')).toBe(true)
+
+ for (const method of ['shareFiles', 'disconnect', 'closePeers', 'peersList'] as const) {
+ expect(runsWithoutWaiting(method)).toBe(false)
+ expect(isFileTransfer(method)).toBe(false)
+ }
+ })
+})
+
+describe('target naming', () => {
+ const download = async (
+ receiver: TransferReceiver,
+ request: DownloadFileRequest,
+ src: string
+ ) => {
+ const [socketA, socketB] = socketPair()
+ const senderSide = PeerDrive.create(socketA)!
+ const receiverSide = PeerDrive.create(socketB)!
+ await senderSide.supported
+
+ const { callbacks } = collect()
+ callbacks.onFileStart = () => {
+ senderSide
+ .serve(request.fileId, 'in.bin', src)
+ .catch((err) => console.error('test setup failed', err))
+ }
+ const [result] = await receiver.downloadFiles([request], callbacks, undefined, async () =>
+ receiverSide.session(request.fileId)
+ )
+ return result
+ }
+
+ const baseRequest = (dst: string): DownloadFileRequest => ({
+ transferId: 't1',
+ fileId: 'f1',
+ driveKey: 'a'.repeat(64),
+ path: '/in.bin',
+ name: 'in.bin',
+ size: 64,
+ targetPath: dst
+ })
+
+ it('recycles an orphaned .part instead of shifting the name forever', async () => {
+ dir = await mkdtemp(join(tmpdir(), 'core-orphan-'))
+ const src = join(dir, 'in.bin')
+ await writeFile(src, new Uint8Array(64).fill(6))
+ const dst = join(dir, 'out.bin')
+ await writeFile(`${dst}.part`, new Uint8Array(999))
+
+ const result = await download(new TransferReceiver(unusableStore()), baseRequest(dst), src)
+ expect(result.ok).toBe(true)
+ expect(result.savedTo).toBe(dst)
+ expect(Buffer.from(await readFile(dst))).toEqual(Buffer.from(new Uint8Array(64).fill(6)))
+ await expect(stat(`${dst}.part`)).rejects.toThrow()
+ })
+
+ it('still steps aside for a real file that already exists', async () => {
+ dir = await mkdtemp(join(tmpdir(), 'core-exists-'))
+ const src = join(dir, 'in.bin')
+ await writeFile(src, new Uint8Array(64).fill(7))
+ const dst = join(dir, 'out.bin')
+ await writeFile(dst, 'PRE-EXISTING')
+
+ const result = await download(new TransferReceiver(unusableStore()), baseRequest(dst), src)
+ expect(result.ok).toBe(true)
+ expect(result.savedTo).toBe(join(dir, 'out (1).bin'))
+ expect(await readFile(dst, 'utf8')).toBe('PRE-EXISTING')
+ })
+})
+
+describe('pausing a file that has not started yet', () => {
+ it('stops it from starting instead of skipping to it', async () => {
+ dir = await mkdtemp(join(tmpdir(), 'core-queued-'))
+ const src = join(dir, 'in.bin')
+ await writeFile(src, new Uint8Array(4 * 1024 * 1024).fill(9))
+
+ const make = (id: string): DownloadFileRequest => ({
+ transferId: 't1',
+ fileId: id,
+ driveKey: 'a'.repeat(64),
+ path: '/in.bin',
+ name: `${id}.bin`,
+ size: 4 * 1024 * 1024,
+ targetPath: join(dir, `${id}.bin`)
+ })
+
+ const [socketA, socketB] = socketPair()
+ const senderSide = PeerDrive.create(socketA)!
+ const receiverSide = PeerDrive.create(socketB)!
+ await senderSide.supported
+
+ const receiver = new TransferReceiver(unusableStore())
+ const started: string[] = []
+ const { callbacks } = collect()
+ callbacks.onFileStart = (event) => {
+ started.push(event.fileId)
+ senderSide
+ .serve(event.fileId, `${event.fileId}.bin`, src)
+ .catch((err) => console.error('test setup failed', err))
+ }
+ callbacks.onFileProgress = (event) => {
+ if (event.fileId === 'f1') expect(receiver.pause('f2')).toBe(true)
+ }
+
+ const results = await receiver.downloadFiles(
+ [make('f1'), make('f2')],
+ callbacks,
+ undefined,
+ async (file) => receiverSide.session(file.fileId)
+ )
+
+ expect(started).toEqual(['f1'])
+ expect(results[0].ok).toBe(true)
+ expect(results[1].ok).toBe(false)
+ expect(results[1].message).toBe('Cancelled')
+ })
+})
diff --git a/packages/core/src/worklet/transfer/sender.test.ts b/packages/core/src/worklet/transfer/sender.test.ts
index d5a90b4..c5a1cbf 100644
--- a/packages/core/src/worklet/transfer/sender.test.ts
+++ b/packages/core/src/worklet/transfer/sender.test.ts
@@ -4,6 +4,7 @@ import { tmpdir } from 'node:os'
import { join } from 'node:path'
import type Hyperdrive from 'hyperdrive'
import type Localdrive from 'localdrive'
+import { LegacyPeerStaging } from './legacy/staging'
import { TransferSender, type ScannedFile } from './sender'
function untouchableDrive(): Hyperdrive {
@@ -114,7 +115,7 @@ describe('TransferSender staging races', () => {
})
const importing = vi
.spyOn(
- TransferSender.prototype as unknown as { importToDrive: () => Promise<void> },
+ LegacyPeerStaging.prototype as unknown as { importToDrive: () => Promise<void> },
'importToDrive'
)
.mockImplementation(() => stuck)
diff --git a/packages/core/src/worklet/transfer/sender.ts b/packages/core/src/worklet/transfer/sender.ts
index 5f5a881..3870067 100644
--- a/packages/core/src/worklet/transfer/sender.ts
+++ b/packages/core/src/worklet/transfer/sender.ts
@@ -1,10 +1,9 @@
import crypto from 'hypercore-crypto'
import fs from 'bare-fs'
-import b4a from 'b4a'
import Localdrive from 'localdrive'
-import MirrorDrive from 'mirror-drive'
import type Hyperdrive from 'hyperdrive'
-import { AbortError, getDirname, getFileName, toRelativePath } from './utils'
+import { getDirname, getFileName, toRelativePath } from './utils'
+import { LegacyPeerStaging } from './legacy/staging'
import type { FileOffer } from './control-channel'
export interface ScannedFile {
@@ -47,15 +46,13 @@ function resolveSource(
}
export class TransferSender {
- private readonly drive: Hyperdrive
+ readonly legacy: LegacyPeerStaging
private readonly scanDrives: Set<Localdrive> = new Set()
private readonly sourcePaths = new Map<string, string>()
private readonly temporaryPaths = new Set<string>()
- private pendingStage: ScannedFile[] = []
- private staging: Promise<void> | null = null
constructor(drive: Hyperdrive) {
- this.drive = drive
+ this.legacy = new LegacyPeerStaging(drive)
}
localPath(fileId: string): string | null {
@@ -63,7 +60,7 @@ export class TransferSender {
}
get driveKey(): string {
- return b4a.toString(this.drive.key, 'hex')
+ return this.legacy.driveKey
}
async scanFiles(
@@ -90,7 +87,7 @@ export class TransferSender {
const entry = await sourceDrive.entry(sourcePath)
if (!entry?.value?.blob) {
- const existingEntry = await this.drive.entry(sourcePath)
+ const existingEntry = await this.legacy.stagedEntry(sourcePath)
if (existingEntry?.value?.blob) {
const size = existingEntry.value.blob.byteLength
totalBytes += size
@@ -137,7 +134,7 @@ export class TransferSender {
}
buildOffers(files: ScannedFile[], transferId: string): FileOffer[] {
- this.pendingStage = files
+ this.legacy.setPendingFiles(files)
return files.map((file) => {
const id = createFileId()
@@ -156,43 +153,12 @@ export class TransferSender {
}
stageForLegacyPeers(onStaging: (file: ScannedFile) => void, signal?: AbortSignal): Promise<void> {
- if (!this.staging) {
- const run: Promise<void> = this.runStaging(onStaging, signal).catch((err) => {
- if (this.staging === run) this.staging = null
- throw err
- })
- this.staging = run
- }
- return this.staging
- }
-
- private async runStaging(
- onStaging: (file: ScannedFile) => void,
- signal?: AbortSignal
- ): Promise<void> {
- const files = this.pendingStage
- const superseded = () => this.pendingStage !== files
-
- try {
- for (const file of files) {
- if (signal?.aborted) throw new AbortError()
- onStaging(file)
- if (!file.alreadyStaged) await this.importToDrive(file.sourceDrive, file.sourcePath)
- }
- } catch (err) {
- if (superseded()) return
- throw err
- }
-
- if (superseded()) return
- this.pendingStage = []
- await this.closeSourceDrives()
+ return this.legacy.stage(onStaging, () => this.closeSourceDrives(), signal)
}
async reset(): Promise<void> {
this.sourcePaths.clear()
- this.pendingStage = []
- this.staging = null
+ this.legacy.reset()
await this.closeSourceDrives()
const temporaries = Array.from(this.temporaryPaths)
@@ -202,14 +168,6 @@ export class TransferSender {
}
}
- private async importToDrive(sourceDrive: Localdrive, sourcePath: string): Promise<void> {
- const mirror = new MirrorDrive(sourceDrive, this.drive, {
- entries: [sourcePath],
- prune: false
- })
- await mirror.done()
- }
-
private async tryDeleteFile(filePath: string): Promise<void> {
try {
await fs.promises.unlink(filePath)
diff --git a/packages/core/src/worklet/transfer/utils.ts b/packages/core/src/worklet/transfer/utils.ts
index a592338..809a9d7 100644
--- a/packages/core/src/worklet/transfer/utils.ts
+++ b/packages/core/src/worklet/transfer/utils.ts
@@ -74,7 +74,13 @@ export class AbortError extends Error {
}
}
-export function onAbort(signal: AbortSignal | undefined, abort: () => void): () => void {
+export interface AbortLike {
+ readonly aborted: boolean
+ addEventListener(type: 'abort', listener: () => void): void
+ removeEventListener(type: 'abort', listener: () => void): void
+}
+
+export function onAbort(signal: AbortLike | undefined, abort: () => void): () => void {
if (!signal) return () => {}
if (signal.aborted) {
abort()
@@ -83,3 +89,16 @@ export function onAbort(signal: AbortSignal | undefined, abort: () => void): ()
signal.addEventListener('abort', abort)
return () => signal.removeEventListener('abort', abort)
}
+
+export function getChunkSize(chunk: unknown): number {
+ if (typeof chunk === 'string') return Buffer.byteLength(chunk)
+ if (
+ chunk &&
+ typeof chunk === 'object' &&
+ 'byteLength' in chunk &&
+ typeof (chunk as { byteLength: unknown }).byteLength === 'number'
+ ) {
+ return (chunk as { byteLength: number }).byteLength
+ }
+ return 0
+}
diff --git a/packages/domain/src/index.ts b/packages/domain/src/index.ts
index e9decbd..0159bc3 100644
--- a/packages/domain/src/index.ts
+++ b/packages/domain/src/index.ts
@@ -21,6 +21,7 @@ export * from './send/uploadItemUi'
export * from './receive/pageUi'
export * from './receive/joinCode'
export * from './receive/downloadModel'
+export * from './receive/linkifyText'
export * from './transfer'
export * from './constants'
@@ -28,3 +29,4 @@ export * from './useSimulatedLoading'
export * from './useCopiedFlag'
export * from './pairing'
export * from './feedback'
+export * from './receive/useReceiveDownloads'
diff --git a/packages/domain/src/pairing/usePairingSession.ts b/packages/domain/src/pairing/usePairingSession.ts
index 0b141b1..a38f465 100644
--- a/packages/domain/src/pairing/usePairingSession.ts
+++ b/packages/domain/src/pairing/usePairingSession.ts
@@ -1,5 +1,5 @@
import { useEffect, useRef } from 'react'
-import { loadPeers } from '../transfer/commands'
+import { loadPeers } from '../transfer/binding'
import { useTransferStore } from '../transfer/store'
import { usePairingHost } from './usePairingHost'
import { usePairingJoin } from './usePairingJoin'
diff --git a/packages/domain/src/receive/downloadModel.test.ts b/packages/domain/src/receive/downloadModel.test.ts
index 0342890..9a29225 100644
--- a/packages/domain/src/receive/downloadModel.test.ts
+++ b/packages/domain/src/receive/downloadModel.test.ts
@@ -2,10 +2,20 @@ import { describe, it, expect } from 'vitest'
import type { IncomingFileOffer } from '@altersend/core'
import {
groupReceiveRows,
+ applyDownloadMessage,
+ getDownloadTotals,
getFolderRowDisplay,
- linkifyText,
+ getDownloadRowAction,
+ getDownloadRowDisplay,
+ isResumable,
+ canStopDownload,
+ getFolderRowAction,
+ getPrimaryDownloadAction,
+ getPrimaryDownloadLabel,
+ markDownloadsQueued,
type DownloadItemState
} from './downloadModel'
+import { linkifyText } from './linkifyText'
type FileOffer = Extract<IncomingFileOffer, { kind: 'file' }>
@@ -145,3 +155,355 @@ describe('linkifyText', () => {
expect(segments).toEqual([{ text: hostile, url: hostile }])
})
})
+
+describe('getDownloadRowDisplay resumability', () => {
+ const failedAt = (resumable: boolean): DownloadItemState => ({
+ status: 'failed',
+ bytesTransferred: 45,
+ totalBytes: 100,
+ message: 'Peer disconnected',
+ resumable
+ })
+
+ it('shows a resumable failure as paused, keeping the progress it reached', () => {
+ const row = getDownloadRowDisplay(offer('/a.bin'), failedAt(true))
+
+ expect(row.status.kind).toBe('paused')
+ expect(row.progressPercent).toBe(45)
+ expect(row.isCompleted).toBe(false)
+ })
+
+ it('shows a non-resumable failure as failed', () => {
+ expect(getDownloadRowDisplay(offer('/a.bin'), failedAt(false)).status.kind).toBe('failed')
+ })
+})
+
+describe('queued rows', () => {
+ it('shows waiting only while another file is transferring', () => {
+ expect(getDownloadRowDisplay(offer('/a.bin'), undefined, true).status.kind).toBe('waiting')
+ expect(getDownloadRowDisplay(offer('/a.bin'), undefined, false).status.kind).toBe('ready')
+ })
+
+ it('treats only a resumable failure with a saved path as resumable', () => {
+ const base = { status: 'failed' as const, bytesTransferred: 1, totalBytes: 2 }
+ expect(isResumable({ ...base, resumable: true, savedTo: '/out.bin' })).toBe(true)
+ expect(isResumable({ ...base, resumable: true })).toBe(false)
+ expect(isResumable({ ...base, savedTo: '/out.bin' })).toBe(false)
+ expect(isResumable(undefined)).toBe(false)
+ })
+})
+
+describe('paused files in aggregates', () => {
+ const paused: DownloadItemState = {
+ status: 'failed',
+ bytesTransferred: 45,
+ totalBytes: 100,
+ savedTo: '/out/a.bin',
+ resumable: true
+ }
+ const broken: DownloadItemState = { status: 'failed', bytesTransferred: 0, totalBytes: 100 }
+
+ it('keeps a paused file bytes in the totals so progress cannot run backwards', () => {
+ const offers = [offer('/a.bin')]
+ const active = getDownloadTotals(offers, {
+ '/a.bin': { status: 'downloading', bytesTransferred: 45, totalBytes: 100 }
+ })
+ const stopped = getDownloadTotals(offers, { '/a.bin': paused })
+
+ expect(stopped.bytesTransferred).toBe(active.bytesTransferred)
+ })
+
+ it('shows a folder with a paused child as paused, not failed', () => {
+ const offers = [offer('/d/a.bin'), offer('/d/b.bin')]
+ const row = getFolderRowDisplay(offers, { '/d/a.bin': paused })
+
+ expect(row.status.kind).toBe('paused')
+ })
+
+ it('still shows a folder as failed when a child failed unrecoverably', () => {
+ const offers = [offer('/d/a.bin'), offer('/d/b.bin')]
+ const row = getFolderRowDisplay(offers, { '/d/a.bin': broken })
+
+ expect(row.status.kind).toBe('failed')
+ })
+})
+
+describe('resuming state', () => {
+ const paused: DownloadItemState = {
+ status: 'failed',
+ bytesTransferred: 90,
+ totalBytes: 100,
+ savedTo: '/out/a.bin',
+ resumable: true
+ }
+
+ it('keeps the progress it had instead of flashing back to zero', () => {
+ const next = applyDownloadMessage({ '/a.bin': paused }, '/a.bin', {
+ type: 'status',
+ state: 'downloading',
+ fileId: '/a.bin',
+ totalBytes: 100,
+ bytesTransferred: 0
+ })
+
+ expect(next['/a.bin'].bytesTransferred).toBe(90)
+ expect(getDownloadRowDisplay(offer('/a.bin'), next['/a.bin']).status.kind).toBe('resuming')
+ })
+
+ it('switches to live progress once real bytes arrive', () => {
+ const started = applyDownloadMessage({ '/a.bin': paused }, '/a.bin', {
+ type: 'status',
+ state: 'downloading',
+ fileId: '/a.bin',
+ totalBytes: 100,
+ bytesTransferred: 0
+ })
+ const next = applyDownloadMessage(started, '/a.bin', {
+ type: 'status',
+ state: 'download-progress',
+ fileId: '/a.bin',
+ totalBytes: 100,
+ bytesTransferred: 95
+ })
+
+ expect(next['/a.bin'].bytesTransferred).toBe(95)
+ expect(getDownloadRowDisplay(offer('/a.bin'), next['/a.bin']).status.kind).toBe('progress')
+ })
+})
+
+describe('queued downloads', () => {
+ const paused: DownloadItemState = {
+ status: 'failed',
+ bytesTransferred: 50,
+ totalBytes: 100,
+ resumable: true,
+ savedTo: '/dl/a.bin'
+ }
+
+ it('shows a queued paused file as waiting, not paused', () => {
+ const file = offer('/a.bin')
+ expect(getDownloadRowDisplay(file, paused).status.kind).toBe('paused')
+ expect(getDownloadRowDisplay(file, { ...paused, queued: true }).status.kind).toBe('waiting')
+ })
+
+ it('shows a queued idle file as waiting even before anything is active', () => {
+ const file = offer('/a.bin')
+ const idle: DownloadItemState = { status: 'idle', bytesTransferred: 0, totalBytes: 100 }
+ expect(getDownloadRowDisplay(file, idle).status.kind).toBe('ready')
+ expect(getDownloadRowDisplay(file, { ...idle, queued: true }).status.kind).toBe('waiting')
+ })
+
+ it('marks and unmarks only the requested keys, skipping active downloads', () => {
+ const states: Record<string, DownloadItemState> = {
+ a: { ...paused },
+ b: { status: 'downloading', bytesTransferred: 10, totalBytes: 100 },
+ c: { status: 'idle', bytesTransferred: 0, totalBytes: 100 }
+ }
+ const marked = markDownloadsQueued(states, ['a', 'b'], true)
+ expect(marked.a.queued).toBe(true)
+ expect(marked.b.queued).toBeUndefined()
+ expect(marked.c.queued).toBeUndefined()
+
+ const cleared = markDownloadsQueued(marked, ['a', 'b'], false)
+ expect(cleared.a.queued).toBeUndefined()
+ })
+
+ it('clears queued once the download actually starts', () => {
+ const next = applyDownloadMessage({ a: { ...paused, queued: true } }, 'a', {
+ state: 'downloading',
+ fileId: 'a',
+ bytesTransferred: 50,
+ totalBytes: 100
+ } as never)
+ expect(next.a.queued).toBeUndefined()
+ expect(next.a.status).toBe('downloading')
+ })
+})
+
+describe('pause capability', () => {
+ it('is only set when the transfer announces it', () => {
+ const legacy = applyDownloadMessage({}, 'a', {
+ state: 'downloading',
+ fileId: 'a',
+ bytesTransferred: 1,
+ totalBytes: 100
+ } as never)
+ expect(legacy.a.pausable).toBeUndefined()
+
+ const drive = applyDownloadMessage({}, 'a', {
+ state: 'downloading',
+ fileId: 'a',
+ pausable: true,
+ bytesTransferred: 1,
+ totalBytes: 100
+ } as never)
+ expect(drive.a.pausable).toBe(true)
+ })
+
+ it('survives later progress events that omit the flag', () => {
+ const first = applyDownloadMessage({}, 'a', {
+ state: 'downloading',
+ fileId: 'a',
+ pausable: true,
+ bytesTransferred: 1,
+ totalBytes: 100
+ } as never)
+ const later = applyDownloadMessage(first, 'a', {
+ state: 'downloading',
+ fileId: 'a',
+ bytesTransferred: 50,
+ totalBytes: 100
+ } as never)
+ expect(later.a.pausable).toBe(true)
+ })
+})
+
+describe('folder actions', () => {
+ const active: DownloadItemState = {
+ status: 'downloading',
+ bytesTransferred: 10,
+ totalBytes: 100,
+ pausable: true
+ }
+ const queued: DownloadItemState = {
+ status: 'idle',
+ bytesTransferred: 0,
+ totalBytes: 100,
+ queued: true
+ }
+ const paused: DownloadItemState = {
+ status: 'failed',
+ bytesTransferred: 50,
+ totalBytes: 100,
+ resumable: true,
+ savedTo: '/dl/a.bin'
+ }
+ const done: DownloadItemState = { status: 'completed', bytesTransferred: 100, totalBytes: 100 }
+
+ it('stops a queued file even though it never announced pausable', () => {
+ expect(canStopDownload(queued)).toBe(true)
+ expect(canStopDownload(active)).toBe(true)
+ expect(canStopDownload(done)).toBe(false)
+ expect(canStopDownload(paused)).toBe(false)
+ })
+
+ it('will not stop a legacy download that cannot be resumed', () => {
+ const legacy: DownloadItemState = {
+ status: 'downloading',
+ bytesTransferred: 5,
+ totalBytes: 100
+ }
+ expect(canStopDownload(legacy)).toBe(false)
+ })
+
+ it('offers pause while any child is running or waiting', () => {
+ const offers = [offer('/f/a.bin'), offer('/f/b.bin')]
+ const states = { '/f/a.bin': done, '/f/b.bin': queued }
+ expect(getFolderRowAction(offers, states)).toBe('pause')
+ })
+
+ it('offers resume once every child has stopped', () => {
+ const offers = [offer('/f/a.bin'), offer('/f/b.bin')]
+ const states = { '/f/a.bin': done, '/f/b.bin': paused }
+ expect(getFolderRowAction(offers, states)).toBe('resume')
+ })
+
+ it('offers nothing when the folder is finished', () => {
+ const offers = [offer('/f/a.bin')]
+ expect(getFolderRowAction(offers, { '/f/a.bin': done })).toBe(null)
+ })
+})
+
+describe('primary download action', () => {
+ const base = {
+ hasFiles: true,
+ allDownloaded: false,
+ peerCount: 1,
+ isDownloading: false,
+ canResumeAll: false
+ }
+
+ it('offers resume-all when every incomplete file is paused', () => {
+ expect(getPrimaryDownloadAction({ ...base, canResumeAll: true })).toBe('resume-all')
+ })
+
+ it('shows progress while downloading, even if some are paused', () => {
+ expect(getPrimaryDownloadAction({ ...base, isDownloading: true, canResumeAll: true })).toBe(
+ 'downloading'
+ )
+ })
+
+ it('hides itself with no peer, no files, or nothing left to do', () => {
+ expect(getPrimaryDownloadAction({ ...base, peerCount: 0 })).toBe(null)
+ expect(getPrimaryDownloadAction({ ...base, hasFiles: false })).toBe(null)
+ expect(getPrimaryDownloadAction({ ...base, allDownloaded: true })).toBe(null)
+ })
+
+ it('falls back to download-all', () => {
+ expect(getPrimaryDownloadAction(base)).toBe('download-all')
+ })
+})
+
+describe('open action on saved files', () => {
+ const file = offer('/a.bin')
+
+ it('offers open once a file is saved', () => {
+ const state: DownloadItemState = {
+ status: 'completed',
+ bytesTransferred: 100,
+ totalBytes: 100,
+ savedTo: '/dl/a.bin'
+ }
+ const row = getDownloadRowDisplay(file, state)
+ expect(getDownloadRowAction(row, state)).toEqual({ kind: 'open', savedTo: '/dl/a.bin' })
+ })
+
+ it('offers nothing when the save path is unknown', () => {
+ const state: DownloadItemState = {
+ status: 'completed',
+ bytesTransferred: 100,
+ totalBytes: 100
+ }
+ expect(getDownloadRowAction(getDownloadRowDisplay(file, state), state)).toBe(null)
+ })
+
+ it('still prefers resume for a paused file', () => {
+ const state: DownloadItemState = {
+ status: 'failed',
+ bytesTransferred: 50,
+ totalBytes: 100,
+ resumable: true,
+ savedTo: '/dl/a.bin'
+ }
+ expect(getDownloadRowAction(getDownloadRowDisplay(file, state), state)).toEqual({
+ kind: 'resume',
+ targetPath: '/dl/a.bin'
+ })
+ })
+})
+
+describe('primary button label', () => {
+ const t = ((key: string, vars?: Record<string, unknown>) =>
+ vars ? `${key}:${Object.values(vars).join(',')}` : key) as never
+
+ it('shows progress while downloading', () => {
+ expect(getPrimaryDownloadLabel(t, 'downloading', { percent: 42 })).toBe(
+ 'receive:actions.downloadingPercent:42'
+ )
+ })
+
+ it('shows resume-all when everything is paused', () => {
+ expect(getPrimaryDownloadLabel(t, 'resume-all', { percent: 0 })).toBe(
+ 'receive:actions.resumeAll'
+ )
+ })
+
+ it('adds the size only when one is given', () => {
+ expect(getPrimaryDownloadLabel(t, 'download-all', { percent: 0 })).toBe(
+ 'receive:actions.downloadAll'
+ )
+ expect(getPrimaryDownloadLabel(t, 'download-all', { percent: 0, totalBytes: 1024 })).toBe(
+ 'receive:actions.downloadAllWithSize:1.0 KB'
+ )
+ })
+})
diff --git a/packages/domain/src/receive/downloadModel.ts b/packages/domain/src/receive/downloadModel.ts
index 331f94c..4770762 100644
--- a/packages/domain/src/receive/downloadModel.ts
+++ b/packages/domain/src/receive/downloadModel.ts
@@ -13,6 +13,10 @@ export interface DownloadItemState {
destination?: SaveDestination
intendedDestination?: SaveDestination
message?: string
+ resumable?: boolean
+ starting?: boolean
+ queued?: boolean
+ pausable?: boolean
}
export type DownloadRowStatusTone = 'muted' | 'active' | 'success'
@@ -21,7 +25,7 @@ export interface DownloadRowDisplay {
description: string | undefined
progressPercent: number | undefined
status: {
- kind: 'saved' | 'failed' | 'progress' | 'ready'
+ kind: 'saved' | 'failed' | 'paused' | 'resuming' | 'progress' | 'ready' | 'waiting'
tone: DownloadRowStatusTone
message?: string
}
@@ -44,36 +48,6 @@ export function getOfferKey(file: IncomingFileOffer) {
return file.id
}
-export interface TextSegment {
- text: string
- url?: string
-}
-
-const TRAILING_URL_PUNCT = new Set(['.', ',', ';', ':', '!', '?', ')', ']', '}', "'", '"'])
-
-function stripTrailingPunctuation(url: string): string {
- let end = url.length
- while (end > 0 && TRAILING_URL_PUNCT.has(url[end - 1])) end--
- return url.slice(0, end)
-}
-
-export function linkifyText(text: string): TextSegment[] {
- const pattern = /https?:\/\/[^\s]+/g
- const segments: TextSegment[] = []
- let lastIndex = 0
- let match: RegExpExecArray | null
-
- while ((match = pattern.exec(text)) !== null) {
- const raw = stripTrailingPunctuation(match[0])
- if (match.index > lastIndex) segments.push({ text: text.slice(lastIndex, match.index) })
- segments.push({ text: raw, url: raw })
- lastIndex = match.index + raw.length
- }
-
- if (lastIndex < text.length) segments.push({ text: text.slice(lastIndex) })
- return segments
-}
-
function getProgressPercent(bytesTransferred: number, totalBytes: number) {
if (totalBytes <= 0) return 0
return Math.max(0, Math.min(100, Math.round((bytesTransferred / totalBytes) * 100)))
@@ -97,9 +71,15 @@ export function createDownloadStateMap(
return next
}
+function stoppedRowKind(state: DownloadItemState): DownloadRowDisplay['status']['kind'] {
+ if (state.queued) return 'waiting'
+ return state.resumable ? 'paused' : 'failed'
+}
+
export function getDownloadRowDisplay(
file: IncomingFileOffer,
- state: DownloadItemState | undefined
+ state: DownloadItemState | undefined,
+ transferActive = false
): DownloadRowDisplay {
const totalBytes = state?.totalBytes || (file.kind === 'file' ? file.size : 0)
const percent = getProgressPercent(state?.bytesTransferred ?? 0, totalBytes)
@@ -119,15 +99,32 @@ export function getDownloadRowDisplay(
if (state?.status === 'failed') {
return {
- description: undefined,
+ description: state.resumable
+ ? `${formatFileSize(state.bytesTransferred)} / ${formatFileSize(totalBytes)}`
+ : undefined,
progressPercent: state.bytesTransferred > 0 ? percent : undefined,
- status: { kind: 'failed', tone: 'muted', message: state.message },
+ status: {
+ kind: stoppedRowKind(state),
+ tone: 'muted',
+ message: state.message
+ },
percent,
isActive: false,
isCompleted: false
}
}
+ if (isActive && state!.starting && state!.bytesTransferred > 0) {
+ return {
+ description: `${formatFileSize(state!.bytesTransferred)} / ${formatFileSize(totalBytes)}`,
+ progressPercent: percent,
+ status: { kind: 'resuming', tone: 'muted' },
+ percent,
+ isActive: true,
+ isCompleted: false
+ }
+ }
+
if (isActive) {
return {
description: `${formatFileSize(state!.bytesTransferred)} / ${formatFileSize(totalBytes)}`,
@@ -142,13 +139,106 @@ export function getDownloadRowDisplay(
return {
description: undefined,
progressPercent: undefined,
- status: { kind: 'ready', tone: 'muted' },
+ status: { kind: transferActive || state?.queued ? 'waiting' : 'ready', tone: 'muted' },
percent: 0,
isActive: false,
isCompleted: false
}
}
+export function getDownloadStatusKey(row: DownloadRowDisplay): string | null {
+ switch (row.status.kind) {
+ case 'saved':
+ return 'receive:status.saved'
+ case 'failed':
+ return 'errors:transfer.downloadFailed'
+ case 'paused':
+ return 'receive:status.paused'
+ case 'resuming':
+ return 'receive:status.resuming'
+ case 'progress':
+ return 'receive:status.percent'
+ case 'waiting':
+ return 'receive:status.waiting'
+ case 'ready':
+ return null
+ }
+}
+
+export type DownloadRowAction =
+ | { kind: 'resume'; targetPath: string }
+ | { kind: 'pause' }
+ | { kind: 'open'; savedTo: string }
+ | null
+
+export function getDownloadRowAction(
+ row: DownloadRowDisplay,
+ state: DownloadItemState | undefined
+): DownloadRowAction {
+ if (row.isCompleted && state?.savedTo) return { kind: 'open', savedTo: state.savedTo }
+ if (row.status.kind === 'paused' && state?.savedTo) {
+ return { kind: 'resume', targetPath: state.savedTo }
+ }
+ if (row.isActive && state?.pausable === true) return { kind: 'pause' }
+ return null
+}
+
+export type PrimaryDownloadAction = 'downloading' | 'resume-all' | 'download-all' | null
+
+export interface PrimaryDownloadInput {
+ hasFiles: boolean
+ allDownloaded: boolean
+ peerCount: number
+ isDownloading: boolean
+ canResumeAll: boolean
+}
+
+export function getPrimaryDownloadAction({
+ hasFiles,
+ allDownloaded,
+ peerCount,
+ isDownloading,
+ canResumeAll
+}: PrimaryDownloadInput): PrimaryDownloadAction {
+ if (!hasFiles || allDownloaded || peerCount === 0) return null
+ if (isDownloading) return 'downloading'
+ return canResumeAll ? 'resume-all' : 'download-all'
+}
+
+export type FolderRowAction = 'pause' | 'resume' | null
+
+export function canStopDownload(state: DownloadItemState | undefined): boolean {
+ if (!state) return false
+ if (state.status === 'downloading') return state.pausable === true
+ return state.queued === true
+}
+
+export function getFolderRowAction(
+ offers: IncomingFileOffer[],
+ states: Record<string, DownloadItemState>
+): FolderRowAction {
+ let resumable = false
+ for (const offer of offers) {
+ const state = states[getOfferKey(offer)]
+ if (canStopDownload(state)) return 'pause'
+ if (isResumable(state)) resumable = true
+ }
+ return resumable ? 'resume' : null
+}
+
+export function isResumable(state: DownloadItemState | undefined): boolean {
+ return state?.status === 'failed' && state.resumable === true && !!state.savedTo
+}
+
+export function getPendingDownloadOffers(
+ offers: IncomingFileOffer[],
+ states: Record<string, DownloadItemState>
+): IncomingFileOffer[] {
+ return offers.filter(
+ (offer) => offer.kind === 'file' && states[getOfferKey(offer)]?.status !== 'completed'
+ )
+}
+
export function resolveOfferKey(offers: IncomingFileOffer[], message: ReceiveDownloadStatusEvent) {
if (typeof message.fileId === 'string') {
const match = offers.find((offer) => offer.id === message.fileId)
@@ -164,6 +254,20 @@ export function resolveOfferKey(offers: IncomingFileOffer[], message: ReceiveDow
const pickNumber = (value: unknown, fallback: number): number =>
typeof value === 'number' ? value : fallback
+export function markDownloadsQueued(
+ current: Record<string, DownloadItemState>,
+ offerKeys: string[],
+ queued: boolean
+): Record<string, DownloadItemState> {
+ const next = { ...current }
+ for (const key of offerKeys) {
+ const previous = next[key]
+ if (!previous || previous.status === 'downloading') continue
+ next[key] = { ...previous, queued: queued || undefined }
+ }
+ return next
+}
+
export function applyDownloadMessage(
current: Record<string, DownloadItemState>,
offerKey: string,
@@ -194,17 +298,31 @@ export function applyDownloadMessage(
[offerKey]: {
...previous,
status: 'failed',
- message: message.message
+ queued: undefined,
+ message: message.message,
+ savedTo: message.savedTo ?? previous.savedTo,
+ resumable: message.resumable === true
}
}
}
+ const starting = message.state === 'downloading' && isResumable(previous)
+
return {
...current,
[offerKey]: {
+ ...previous,
status: 'downloading',
- bytesTransferred: pickNumber(message.bytesTransferred, previous.bytesTransferred),
- totalBytes: pickNumber(message.totalBytes, previous.totalBytes)
+ resumable: undefined,
+ queued: undefined,
+ pausable: message.pausable === true || previous.pausable,
+ starting,
+ bytesTransferred:
+ starting && isResumable(previous)
+ ? previous.bytesTransferred
+ : pickNumber(message.bytesTransferred, previous.bytesTransferred),
+ totalBytes: pickNumber(message.totalBytes, previous.totalBytes),
+ savedTo: message.savedTo ?? previous.savedTo
}
}
}
@@ -251,6 +369,11 @@ export function getDownloadTotals(
if (state.status === 'downloading') {
activeCount += 1
bytesTransferred += Math.min(state.bytesTransferred, state.totalBytes || file.size)
+ continue
+ }
+
+ if (isResumable(state)) {
+ bytesTransferred += Math.min(state.bytesTransferred, state.totalBytes || file.size)
}
}
@@ -316,7 +439,11 @@ export function getFolderRowDisplay(
states: Record<string, DownloadItemState>
): DownloadRowDisplay {
const totals = getDownloadTotals(offers, states)
- const anyFailed = offers.some((offer) => states[getOfferKey(offer)]?.status === 'failed')
+ const anyFailed = offers.some((offer) => {
+ const state = states[getOfferKey(offer)]
+ return state?.status === 'failed' && !isResumable(state)
+ })
+ const anyPaused = offers.some((offer) => isResumable(states[getOfferKey(offer)]))
if (totals.completedCount === offers.length) {
return {
@@ -329,7 +456,7 @@ export function getFolderRowDisplay(
}
}
- if (anyFailed) {
+ if (anyFailed && totals.activeCount === 0 && !anyPaused) {
return {
description: undefined,
progressPercent: totals.bytesTransferred > 0 ? totals.percent : undefined,
@@ -340,11 +467,14 @@ export function getFolderRowDisplay(
}
}
- if (totals.activeCount > 0 || totals.completedCount > 0) {
+ if (totals.activeCount > 0 || totals.completedCount > 0 || anyPaused) {
return {
description: `${formatFileSize(totals.bytesTransferred)} / ${formatFileSize(totals.totalBytes)}`,
progressPercent: totals.percent,
- status: { kind: 'progress', tone: totals.percent > 0 ? 'active' : 'muted' },
+ status: {
+ kind: totals.activeCount === 0 && anyPaused ? 'paused' : 'progress',
+ tone: totals.activeCount > 0 && totals.percent > 0 ? 'active' : 'muted'
+ },
percent: totals.percent,
isActive: totals.activeCount > 0,
isCompleted: false
@@ -363,7 +493,8 @@ export function getFolderRowDisplay(
export function createSingleDownloadRequest(
file: IncomingFileOffer,
- targetPath: string
+ targetPath: string,
+ overwrite = false
): DownloadFileRequest {
if (file.kind !== 'file') throw new Error('createSingleDownloadRequest: expected FileOffer')
return {
@@ -373,7 +504,8 @@ export function createSingleDownloadRequest(
path: file.path,
name: file.name,
size: file.size,
- targetPath
+ targetPath,
+ overwrite
}
}
@@ -393,3 +525,45 @@ export function createDirectoryDownloadRequests(
targetDir
}))
}
+
+export interface DownloadRowLabels {
+ status?: string
+ resume: string
+ pause: string
+ open: string
+}
+
+export interface PrimaryLabelOptions {
+ percent: number
+ totalBytes?: number
+}
+
+export function getPrimaryDownloadLabel(
+ t: (key: string, vars?: Record<string, unknown>) => string,
+ action: PrimaryDownloadAction,
+ { percent, totalBytes }: PrimaryLabelOptions
+): string {
+ switch (action) {
+ case 'downloading':
+ return t('receive:actions.downloadingPercent', { percent })
+ case 'resume-all':
+ return t('receive:actions.resumeAll')
+ default:
+ return totalBytes && totalBytes > 0
+ ? t('receive:actions.downloadAllWithSize', { size: formatFileSize(totalBytes) })
+ : t('receive:actions.downloadAll')
+ }
+}
+
+export function getDownloadRowLabels(
+ t: (key: string, vars?: Record<string, unknown>) => string,
+ row: DownloadRowDisplay
+): DownloadRowLabels {
+ const key = getDownloadStatusKey(row)
+ return {
+ status: key ? t(key, { percent: row.percent }) : undefined,
+ resume: t('receive:actions.resume'),
+ pause: t('receive:actions.stop'),
+ open: t('receive:actions.open')
+ }
+}
diff --git a/packages/domain/src/receive/linkifyText.ts b/packages/domain/src/receive/linkifyText.ts
new file mode 100644
index 0000000..732291c
--- /dev/null
+++ b/packages/domain/src/receive/linkifyText.ts
@@ -0,0 +1,29 @@
+export interface TextSegment {
+ text: string
+ url?: string
+}
+
+const TRAILING_URL_PUNCT = new Set(['.', ',', ';', ':', '!', '?', ')', ']', '}', "'", '"'])
+
+function stripTrailingPunctuation(url: string): string {
+ let end = url.length
+ while (end > 0 && TRAILING_URL_PUNCT.has(url[end - 1])) end--
+ return url.slice(0, end)
+}
+
+export function linkifyText(text: string): TextSegment[] {
+ const pattern = /https?:\/\/[^\s]+/g
+ const segments: TextSegment[] = []
+ let lastIndex = 0
+ let match: RegExpExecArray | null
+
+ while ((match = pattern.exec(text)) !== null) {
+ const raw = stripTrailingPunctuation(match[0])
+ if (match.index > lastIndex) segments.push({ text: text.slice(lastIndex, match.index) })
+ segments.push({ text: raw, url: raw })
+ lastIndex = match.index + raw.length
+ }
+
+ if (lastIndex < text.length) segments.push({ text: text.slice(lastIndex) })
+ return segments
+}
diff --git a/packages/domain/src/receive/useReceiveDownloads.ts b/packages/domain/src/receive/useReceiveDownloads.ts
new file mode 100644
index 0000000..cec536d
--- /dev/null
+++ b/packages/domain/src/receive/useReceiveDownloads.ts
@@ -0,0 +1,175 @@
+import { useCallback, useMemo } from 'react'
+import type { IncomingFileOffer } from '@altersend/core'
+import { useTransferStore } from '../transfer/store'
+import { downloadFiles, pauseDownload } from '../transfer/commands'
+import {
+ createDirectoryDownloadRequests,
+ createSingleDownloadRequest,
+ getDownloadTotals,
+ getOfferKey,
+ canStopDownload,
+ getPendingDownloadOffers,
+ getPrimaryDownloadAction,
+ groupReceiveRows,
+ isResumable,
+ type DownloadItemState,
+ type DownloadTotals,
+ type PrimaryDownloadAction,
+ type ReceiveRow
+} from './downloadModel'
+
+export type ReceiveFileOffer = Extract<IncomingFileOffer, { kind: 'file' }>
+export type ReceiveTextOffer = Extract<IncomingFileOffer, { kind: 'text' }>
+
+export interface ReceiveDownloads {
+ rows: ReceiveRow[]
+ fileOffers: ReceiveFileOffer[]
+ textOffers: ReceiveTextOffer[]
+ pendingOffers: ReceiveFileOffer[]
+ pausedOffers: ReceiveFileOffer[]
+ states: Record<string, DownloadItemState>
+ totals: DownloadTotals
+ hasFiles: boolean
+ isDownloading: boolean
+ allDownloaded: boolean
+ canResumeAll: boolean
+ primaryAction: PrimaryDownloadAction
+}
+
+export function useReceiveDownloads(): ReceiveDownloads {
+ const incomingFileOffers = useTransferStore((s) => s.incomingFileOffers)
+ const states = useTransferStore((s) => s.receiveDownloadStates)
+ const peerCount = useTransferStore((s) => s.peerCount)
+
+ const rows = useMemo(() => groupReceiveRows(incomingFileOffers), [incomingFileOffers])
+ const totals = useMemo(
+ () => getDownloadTotals(incomingFileOffers, states),
+ [incomingFileOffers, states]
+ )
+ const fileOffers = useMemo(
+ () => incomingFileOffers.filter((o): o is ReceiveFileOffer => o.kind === 'file'),
+ [incomingFileOffers]
+ )
+ const textOffers = useMemo(
+ () => incomingFileOffers.filter((o): o is ReceiveTextOffer => o.kind === 'text'),
+ [incomingFileOffers]
+ )
+ const pendingOffers = useMemo(
+ () => getPendingDownloadOffers(fileOffers, states) as ReceiveFileOffer[],
+ [fileOffers, states]
+ )
+ const pausedOffers = useMemo(
+ () => fileOffers.filter((offer) => isResumable(states[getOfferKey(offer)])),
+ [fileOffers, states]
+ )
+
+ const isDownloading = totals.activeCount > 0
+ const hasFiles = fileOffers.length > 0
+ const allDownloaded = hasFiles && totals.completedCount === fileOffers.length
+ const canResumeAll =
+ !isDownloading && pausedOffers.length > 0 && pausedOffers.length === pendingOffers.length
+
+ const primaryAction = getPrimaryDownloadAction({
+ hasFiles,
+ allDownloaded,
+ peerCount,
+ isDownloading,
+ canResumeAll
+ })
+
+ return {
+ rows,
+ fileOffers,
+ textOffers,
+ pendingOffers,
+ pausedOffers,
+ states,
+ totals,
+ hasFiles,
+ isDownloading,
+ allDownloaded,
+ canResumeAll,
+ primaryAction
+ }
+}
+
+export interface ReceiveActions {
+ resumeFile: (offer: ReceiveFileOffer, targetPath: string) => void
+ pauseFile: (offer: ReceiveFileOffer) => void
+ pauseFolder: (offers: ReceiveFileOffer[]) => void
+ resumeFolder: (offers: ReceiveFileOffer[]) => void
+ resumeAll: () => Promise<void>
+ downloadInto: (targetDir: string) => Promise<void>
+ replaceWith: (offer: ReceiveFileOffer, targetPath: string) => Promise<void>
+}
+
+const report = (label: string) => (err: unknown) => console.warn(`Receive: ${label} failed`, err)
+
+export function useReceiveActions(downloads: ReceiveDownloads): ReceiveActions {
+ const { states, pausedOffers, pendingOffers } = downloads
+
+ const resumeFile = useCallback((offer: ReceiveFileOffer, targetPath: string) => {
+ downloadFiles([createSingleDownloadRequest(offer, targetPath)]).catch(report('resume'))
+ }, [])
+
+ const pauseFile = useCallback((offer: ReceiveFileOffer) => {
+ pauseDownload(getOfferKey(offer)).catch(report('pause'))
+ }, [])
+
+ const pauseFolder = useCallback(
+ (offers: ReceiveFileOffer[]) => {
+ const stoppable = offers.filter((offer) => canStopDownload(states[getOfferKey(offer)]))
+ Promise.all(stoppable.map((offer) => pauseDownload(getOfferKey(offer)))).catch(
+ report('pause folder')
+ )
+ },
+ [states]
+ )
+
+ const resumeFolder = useCallback(
+ (offers: ReceiveFileOffer[]) => {
+ const requests = offers
+ .map((offer) => {
+ const state = states[getOfferKey(offer)]
+ return isResumable(state) && state?.savedTo
+ ? createSingleDownloadRequest(offer, state.savedTo)
+ : null
+ })
+ .filter((request) => request !== null)
+ if (requests.length > 0) downloadFiles(requests).catch(report('resume folder'))
+ },
+ [states]
+ )
+
+ const resumeAll = useCallback(async () => {
+ const requests = pausedOffers
+ .map((offer) => {
+ const savedTo = states[getOfferKey(offer)]?.savedTo
+ return savedTo ? createSingleDownloadRequest(offer, savedTo) : null
+ })
+ .filter((request) => request !== null)
+ if (requests.length > 0) await downloadFiles(requests)
+ }, [pausedOffers, states])
+
+ const downloadInto = useCallback(
+ async (targetDir: string) => {
+ if (pendingOffers.length === 0) return
+ await downloadFiles(createDirectoryDownloadRequests(pendingOffers, targetDir))
+ },
+ [pendingOffers]
+ )
+
+ const replaceWith = useCallback(async (offer: ReceiveFileOffer, targetPath: string) => {
+ await downloadFiles([createSingleDownloadRequest(offer, targetPath, true)])
+ }, [])
+
+ return {
+ resumeFile,
+ pauseFile,
+ pauseFolder,
+ resumeFolder,
+ resumeAll,
+ downloadInto,
+ replaceWith
+ }
+}
diff --git a/packages/domain/src/send/peerListUi.ts b/packages/domain/src/send/peerListUi.ts
index 8ba4c5b..2469689 100644
--- a/packages/domain/src/send/peerListUi.ts
+++ b/packages/domain/src/send/peerListUi.ts
@@ -44,6 +44,15 @@ function getStatusDetail(data: PeerStatusData): PeerListEntryDetail | null {
switch (data.status) {
case 'failed':
return data.failedFileName ? { type: 'failed-file', fileName: data.failedFileName } : null
+ case 'paused':
+ if (data.transferredBytes != null && data.totalForDisplay != null) {
+ return {
+ type: 'progress-bytes',
+ transferredBytes: data.transferredBytes,
+ totalBytes: data.totalForDisplay
+ }
+ }
+ return null
case 'downloaded':
return { type: 'completed-files', count: data.completedCount }
case 'disconnected':
diff --git a/packages/domain/src/send/shareModel.ts b/packages/domain/src/send/shareModel.ts
index 3926896..96925f1 100644
--- a/packages/domain/src/send/shareModel.ts
+++ b/packages/domain/src/send/shareModel.ts
@@ -12,7 +12,7 @@ export interface ConnectedPeer {
disconnectedAt?: number
}
-export type PeerDownloadState = 'started' | 'progress' | 'completed' | 'failed'
+export type PeerDownloadState = 'started' | 'progress' | 'completed' | 'failed' | 'paused'
export interface PeerDownloadEvent {
id: string
@@ -25,7 +25,13 @@ export interface PeerDownloadEvent {
updatedAt: number
}
-export type PeerListStatus = 'online' | 'downloading' | 'downloaded' | 'failed' | 'disconnected'
+export type PeerListStatus =
+ | 'online'
+ | 'downloading'
+ | 'downloaded'
+ | 'paused'
+ | 'failed'
+ | 'disconnected'
export interface PeerStatusData {
status: PeerListStatus
@@ -53,7 +59,7 @@ function getPeerDownloadState(
case 'peer-downloaded':
return 'completed'
case 'peer-download-failed':
- return 'failed'
+ return message.paused === true ? 'paused' : 'failed'
default:
return null
}
@@ -90,6 +96,7 @@ export function applyPeerDownloadEvent(
interface EventsSummary {
failed: PeerDownloadEvent | null
+ paused: PeerDownloadEvent | null
inFlight: PeerDownloadEvent | null
newest: PeerDownloadEvent
completedCount: number
@@ -101,6 +108,7 @@ function summarizeEvents(events: PeerDownloadEvent[]): EventsSummary | null {
if (events.length === 0) return null
let failed: PeerDownloadEvent | null = null
+ let paused: PeerDownloadEvent | null = null
let inFlight: PeerDownloadEvent | null = null
let newest = events[0]
let completedCount = 0
@@ -115,6 +123,10 @@ function summarizeEvents(events: PeerDownloadEvent[]): EventsSummary | null {
case 'failed':
failed ??= event
break
+ case 'paused':
+ paused ??= event
+ transferredBytes += event.bytesTransferred
+ break
case 'started':
case 'progress':
inFlight ??= event
@@ -127,7 +139,7 @@ function summarizeEvents(events: PeerDownloadEvent[]): EventsSummary | null {
}
}
- return { failed, inFlight, newest, completedCount, transferredBytes, sumOfKnownTotals }
+ return { failed, paused, inFlight, newest, completedCount, transferredBytes, sumOfKnownTotals }
}
export function derivePeerStatus(
@@ -145,7 +157,8 @@ export function derivePeerStatus(
}
}
- const { failed, inFlight, newest, completedCount, transferredBytes, sumOfKnownTotals } = summary
+ const { failed, paused, inFlight, newest, completedCount, transferredBytes, sumOfKnownTotals } =
+ summary
if (failed) {
return {
@@ -164,6 +177,16 @@ export function derivePeerStatus(
return { status: 'disconnected', completedCount, sortKey: newest.updatedAt }
}
+ if (paused && !inFlight) {
+ return {
+ status: 'paused',
+ completedCount,
+ transferredBytes,
+ totalForDisplay: sumOfKnownTotals || expectedTotalBytes,
+ sortKey: paused.updatedAt
+ }
+ }
+
if (inFlight) {
const totalForDisplay = expectedTotalBytes > 0 ? expectedTotalBytes : sumOfKnownTotals
const progressPercent =
diff --git a/packages/domain/src/send/useShareViewModel.ts b/packages/domain/src/send/useShareViewModel.ts
index cfd6b54..3a68bd2 100644
--- a/packages/domain/src/send/useShareViewModel.ts
+++ b/packages/domain/src/send/useShareViewModel.ts
@@ -77,6 +77,8 @@ function statusLabel(status: PeerListEntryWithPair['status'], t: Translate): str
switch (status) {
case 'failed':
return t('send:status.failed')
+ case 'paused':
+ return t('send:status.paused')
case 'downloaded':
return t('send:status.downloaded')
case 'disconnected':
diff --git a/packages/domain/src/transfer/binding.ts b/packages/domain/src/transfer/binding.ts
index 97cd1d0..b480666 100644
--- a/packages/domain/src/transfer/binding.ts
+++ b/packages/domain/src/transfer/binding.ts
@@ -1,7 +1,6 @@
import { dispatchToTransferStore } from './store'
import { getTransferDebugMessage, getTransferErrorCode } from './errors'
import { TRANSFER_ERROR_CODES } from './types'
-import { loadPeers } from './commands'
import type { SharingStatusEvent } from '../send/draftModel'
import type { RendererTransferEvent, TransferRPC } from '@altersend/core'
@@ -29,6 +28,15 @@ export function getTransferApi(): TransferApi {
return api
}
+export async function loadPeers(): Promise<void> {
+ try {
+ const peers = await getTransferApi().worker.peersList()
+ dispatchToTransferStore({ type: 'set_peers', peers })
+ } catch (error) {
+ reportError('loadPeers', error)
+ }
+}
+
export function reportError(context: string, error: unknown): void {
if (errorHandler) {
errorHandler(context, error)
@@ -103,6 +111,34 @@ function dispatchRendererEvent(event: RendererTransferEvent): void {
}
}
+const PROGRESS_FLUSH_MS = 100
+const pendingProgress = new Map<string, () => void>()
+let progressTimer: ReturnType<typeof setTimeout> | null = null
+
+function stopProgressTimer(): void {
+ if (!progressTimer) return
+ clearTimeout(progressTimer)
+ progressTimer = null
+}
+
+function queueProgress(key: string, dispatch: () => void): void {
+ pendingProgress.set(key, dispatch)
+ if (progressTimer) return
+ progressTimer = setTimeout(flushProgress, PROGRESS_FLUSH_MS)
+}
+
+function flushProgress(): void {
+ stopProgressTimer()
+ const pending = Array.from(pendingProgress.values())
+ pendingProgress.clear()
+ for (const dispatch of pending) dispatch()
+}
+
+export function discardPendingProgress(): void {
+ stopProgressTimer()
+ pendingProgress.clear()
+}
+
function dispatchStatusEvent(event: StatusEvent): void {
switch (event.state) {
case 'reconnecting':
@@ -112,15 +148,23 @@ function dispatchStatusEvent(event: StatusEvent): void {
type: 'apply_sharing_progress',
event: event as SharingStatusEvent
})
- case 'peer-download-started':
case 'peer-download-progress':
+ return queueProgress(`peer:${event.peer ?? ''}:${event.fileId ?? ''}`, () =>
+ dispatchToTransferStore({ type: 'peer_download_event', event })
+ )
+ case 'peer-download-started':
case 'peer-downloaded':
case 'peer-download-failed':
+ flushProgress()
return dispatchToTransferStore({ type: 'peer_download_event', event })
- case 'downloading':
case 'download-progress':
+ return queueProgress(`file:${event.fileId ?? ''}`, () =>
+ dispatchToTransferStore({ type: 'receive_download_event', event })
+ )
+ case 'downloading':
case 'downloaded':
case 'download-failed':
+ flushProgress()
return dispatchToTransferStore({ type: 'receive_download_event', event })
case 'peer-connected':
dispatchToTransferStore({ type: 'status_changed', state: event.state, peers: event.peers })
@@ -183,6 +227,7 @@ export function bindTransferApi(
unbindCurrent = () => {
off()
+ discardPendingProgress()
api = null
errorHandler = null
unbindCurrent = null
diff --git a/packages/domain/src/transfer/commands.ts b/packages/domain/src/transfer/commands.ts
index 174ed37..f9311f9 100644
--- a/packages/domain/src/transfer/commands.ts
+++ b/packages/domain/src/transfer/commands.ts
@@ -1,5 +1,5 @@
import { dispatchToTransferStore, transferStore } from './store'
-import { getTransferApi, reportError } from './binding'
+import { discardPendingProgress, getTransferApi, loadPeers, reportError } from './binding'
import { getTransferDebugMessage, getTransferErrorCode } from './errors'
import { TRANSFER_ERROR_CODES, type TransferErrorCode } from './types'
import { createInitialUploadItems, getPhaseFromSelection } from '../send/draftModel'
@@ -23,6 +23,7 @@ const setError = (code: TransferErrorCode, error: unknown): void => {
}
export const clearSession = async (): Promise<void> => {
+ discardPendingProgress()
dispatchToTransferStore({ type: 'clear_session' })
try {
await getTransferApi().worker.disconnect()
@@ -90,13 +91,26 @@ export const shareFiles = async (files: ShareFileRequest[]): Promise<ShareFilesR
}
}
+export const pauseDownload = async (fileId: string): Promise<void> => {
+ try {
+ await getTransferApi().worker.pauseDownload(fileId)
+ } catch (error) {
+ reportError('pauseDownload', error)
+ throw error
+ }
+}
+
export const downloadFiles = async (files: DownloadFileRequest[]): Promise<DownloadFilesReply> => {
+ const offerKeys = files.map((f) => f.fileId)
+ dispatchToTransferStore({ type: 'downloads_queued', offerKeys, queued: true })
try {
return await getTransferApi().worker.downloadFiles(files)
} catch (error) {
reportError('downloadFiles', error)
setError(TRANSFER_ERROR_CODES.downloadFailed, error)
throw error
+ } finally {
+ dispatchToTransferStore({ type: 'downloads_queued', offerKeys, queued: false })
}
}
@@ -130,15 +144,6 @@ export function subscribeToPairingPeerConnected(cb: (peerKey: string) => void):
})
}
-export const loadPeers = async (): Promise<void> => {
- try {
- const peers = await getTransferApi().worker.peersList()
- dispatchToTransferStore({ type: 'set_peers', peers })
- } catch (error) {
- reportError('loadPeers', error)
- }
-}
-
export const forgetPeer = async (pubkey: string): Promise<boolean> => {
dispatchToTransferStore({ type: 'forget_peer', peerKey: pubkey })
diff --git a/packages/domain/src/transfer/index.ts b/packages/domain/src/transfer/index.ts
index 634d0d1..17bc064 100644
--- a/packages/domain/src/transfer/index.ts
+++ b/packages/domain/src/transfer/index.ts
@@ -5,6 +5,7 @@ export * from './store'
export * from './commands'
export {
bindTransferApi,
+ loadPeers,
type TransferApi,
type BindTransferApiOptions,
type ErrorHandler
diff --git a/packages/domain/src/transfer/reducer.test.ts b/packages/domain/src/transfer/reducer.test.ts
index 1b54525..de2ba67 100644
--- a/packages/domain/src/transfer/reducer.test.ts
+++ b/packages/domain/src/transfer/reducer.test.ts
@@ -230,6 +230,57 @@ describe('transferSessionReducer — receive flow', () => {
expect(next).toBe(state)
})
+ it('a paused download does not put the page into an error state', () => {
+ const ready = apply(make({ role: 'receiver' }), {
+ type: 'transfer_ready',
+ files: [offer('a', 'a.txt')]
+ })
+
+ const next = apply(ready, {
+ type: 'receive_download_event',
+ event: {
+ type: 'status',
+ state: 'download-failed',
+ transferId: 'tx-1',
+ fileId: 'a',
+ file: 'a.txt',
+ path: '/files/a.txt',
+ totalBytes: 1024,
+ bytesTransferred: 256,
+ message: 'Transfer cancelled',
+ resumable: true
+ }
+ })
+
+ expect(next.errorCode).toBeNull()
+ expect(next.receiveDownloadStates.a.status).toBe('failed')
+ expect(next.receiveDownloadStates.a.resumable).toBe(true)
+ })
+
+ it('a genuine download failure still errors the page', () => {
+ const ready = apply(make({ role: 'receiver' }), {
+ type: 'transfer_ready',
+ files: [offer('a', 'a.txt')]
+ })
+
+ const next = apply(ready, {
+ type: 'receive_download_event',
+ event: {
+ type: 'status',
+ state: 'download-failed',
+ transferId: 'tx-1',
+ fileId: 'a',
+ file: 'a.txt',
+ path: '/files/a.txt',
+ totalBytes: 1024,
+ bytesTransferred: 0,
+ message: 'Full-file hash mismatch'
+ }
+ })
+
+ expect(next.errorCode).toBe(TRANSFER_ERROR_CODES.downloadFailed)
+ })
+
it('receive_download_event preserves an existing transfer error on non-failed updates', () => {
const state = apply(make({ role: 'receiver' }), {
type: 'transfer_ready',
@@ -458,4 +509,29 @@ describe('transferSessionReducer — connection type (per-peer)', () => {
expect(state.transferPeerKey).toBeNull()
expect(state.connectionTypes).toEqual({})
})
+
+ it('a cancelled download does not put the page into an error state', () => {
+ const ready = apply(make({ role: 'receiver' }), {
+ type: 'transfer_ready',
+ files: [offer('a', 'a.txt')]
+ })
+
+ const next = apply(ready, {
+ type: 'receive_download_event',
+ event: {
+ type: 'status',
+ state: 'download-failed',
+ transferId: 'tx-1',
+ fileId: 'a',
+ file: 'a.txt',
+ path: '/files/a.txt',
+ totalBytes: 1024,
+ bytesTransferred: 256,
+ message: 'Cancelled',
+ cancelled: true
+ }
+ })
+
+ expect(next.errorCode).toBeNull()
+ })
})
diff --git a/packages/domain/src/transfer/reducer.ts b/packages/domain/src/transfer/reducer.ts
index de20723..9fbb762 100644
--- a/packages/domain/src/transfer/reducer.ts
+++ b/packages/domain/src/transfer/reducer.ts
@@ -2,6 +2,7 @@ import {
applyDownloadMessage,
applyDownloadRouted,
createDownloadStateMap,
+ markDownloadsQueued,
resolveOfferKey
} from '../receive/downloadModel'
import { applySharingProgress, getPhaseFromSelection, mergeSelectedFiles } from '../send/draftModel'
@@ -311,7 +312,11 @@ export function transferSessionReducer(
offerKey,
action.event
)
- if (action.event.state === 'download-failed') {
+ if (
+ action.event.state === 'download-failed' &&
+ action.event.resumable !== true &&
+ action.event.cancelled !== true
+ ) {
return {
...state,
receiveDownloadStates: nextDownloadStates,
@@ -324,6 +329,17 @@ export function transferSessionReducer(
receiveDownloadStates: nextDownloadStates
}
}
+ case 'downloads_queued': {
+ if (state.role !== 'receiver') return state
+ return {
+ ...state,
+ receiveDownloadStates: markDownloadsQueued(
+ state.receiveDownloadStates,
+ action.offerKeys,
+ action.queued
+ )
+ }
+ }
case 'download_routed':
if (state.role !== 'receiver') return state
return {
diff --git a/packages/domain/src/transfer/types.ts b/packages/domain/src/transfer/types.ts
index bbfc074..e036f20 100644
--- a/packages/domain/src/transfer/types.ts
+++ b/packages/domain/src/transfer/types.ts
@@ -105,6 +105,7 @@ export type TransferAction =
| { type: 'set_draft_phase'; phase: SendDraftPhase }
| { type: 'clear_send_draft' }
| { type: 'receive_download_event'; event: ReceiveDownloadStatusEvent }
+ | { type: 'downloads_queued'; offerKeys: string[]; queued: boolean }
| {
type: 'download_routed'
offerKey: string
diff --git a/packages/drive/package.json b/packages/drive/package.json
index 7cb059b..9a52b19 100644
--- a/packages/drive/package.json
+++ b/packages/drive/package.json
@@ -44,7 +44,8 @@
"dependencies": {
"bare-fs": "^4.7.0",
"bare-path": "^3.0.0",
- "blake2b": "^2.1.4"
+ "blake2b": "^2.1.4",
+ "blake2b-wasm": "^2.4.0"
},
"devDependencies": {
"@types/node": "^22.10.0",
diff --git a/packages/drive/src/adapters/disk-reader.ts b/packages/drive/src/adapters/disk-reader.ts
index 5d9bdbd..563d95e 100644
--- a/packages/drive/src/adapters/disk-reader.ts
+++ b/packages/drive/src/adapters/disk-reader.ts
@@ -6,12 +6,14 @@ import { readRange } from './read-range'
export class DiskReader implements ChunkReader {
private readonly path: string
private opening: Promise<FileHandle> | null = null
+ private closed = false
constructor(path: string) {
this.path = path
}
private handle(): Promise<FileHandle> {
+ if (this.closed) throw new Error('DiskReader is closed')
if (!this.opening) this.opening = fs.open(this.path, 'r')
return this.opening
}
@@ -25,6 +27,7 @@ export class DiskReader implements ChunkReader {
}
async close(): Promise<void> {
+ this.closed = true
const pending = this.opening
this.opening = null
if (!pending) return
diff --git a/packages/drive/src/adapters/disk-writer.ts b/packages/drive/src/adapters/disk-writer.ts
index 82e24a0..5f8eaee 100644
--- a/packages/drive/src/adapters/disk-writer.ts
+++ b/packages/drive/src/adapters/disk-writer.ts
@@ -1,19 +1,28 @@
import fs from '#fs'
+import path from '#path'
import type { FileHandle } from 'node:fs/promises'
import type { ChunkWriter } from '../engine/types'
import { readRange } from './read-range'
+import { firstFreePath } from '../engine/paths'
+
+export interface DiskWriterOptions {
+ overwrite?: boolean
+}
export class DiskWriter implements ChunkWriter {
private readonly targetPath: string
private readonly partPath: string
+ private readonly overwrite: boolean
private handle: FileHandle | null = null
- constructor(targetPath: string) {
+ constructor(targetPath: string, { overwrite = false }: DiskWriterOptions = {}) {
this.targetPath = targetPath
this.partPath = `${targetPath}.part`
+ this.overwrite = overwrite
}
async allocate(size: number): Promise<void> {
+ await fs.mkdir(path.dirname(this.partPath), { recursive: true })
try {
this.handle = await fs.open(this.partPath, 'r+')
} catch (err) {
@@ -25,7 +34,10 @@ export class DiskWriter implements ChunkWriter {
async write(offset: number, data: Uint8Array): Promise<void> {
if (!this.handle) throw new Error('DiskWriter.write before allocate')
- await this.handle.write(data, 0, data.length, offset)
+ const { bytesWritten } = await this.handle.write(data, 0, data.length, offset)
+ if (bytesWritten !== data.length) {
+ throw new Error(`Short write at ${offset}: ${bytesWritten} of ${data.length} bytes`)
+ }
}
async readBack(offset: number, length: number): Promise<Uint8Array | null> {
@@ -34,21 +46,46 @@ export class DiskWriter implements ChunkWriter {
}
async finalize(): Promise<string> {
- if (this.handle) {
- await this.handle.close()
- this.handle = null
- }
- await fs.rename(this.partPath, this.targetPath)
- return this.targetPath
+ await this.closeHandle()
+ const destination = this.overwrite ? this.targetPath : await freePath(this.targetPath)
+ await fs.rename(this.partPath, destination)
+ return destination
}
async abort(): Promise<void> {
- if (this.handle) {
- await this.handle.close()
- this.handle = null
+ await this.closeHandle()
+ }
+
+ private async closeHandle(): Promise<void> {
+ if (!this.handle) return
+ await this.handle.close()
+ this.handle = null
+ }
+}
+
+async function exists(path: string): Promise<boolean> {
+ try {
+ await fs.stat(path)
+ return true
+ } catch {
+ return false
+ }
+}
+
+function freePath(targetPath: string): Promise<string> {
+ return firstFreePath(targetPath, async (candidate) => !(await exists(candidate)))
+}
+
+export function partialPath(targetPath: string): string {
+ return `${targetPath}.part`
+}
+
+export async function discardPartial(targetPath: string): Promise<void> {
+ try {
+ await fs.unlink(partialPath(targetPath))
+ } catch (err) {
+ if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') {
+ console.warn('discardPartial: failed to remove', targetPath, err)
}
- try {
- await fs.unlink(this.partPath)
- } catch {}
}
}
diff --git a/packages/drive/src/api/drive.ts b/packages/drive/src/api/drive.ts
index 07676ac..bd70d6f 100644
--- a/packages/drive/src/api/drive.ts
+++ b/packages/drive/src/api/drive.ts
@@ -1,6 +1,7 @@
import nodePath from '#path'
import type { DriveChannel } from '../engine/types'
import type { Bitmap } from '../engine/bitmap'
+import type { AbortLike } from '../engine/types'
import { SenderSession } from '../engine/sender'
import { ReceiverSession } from '../engine/receiver'
import { DiskReader } from '../adapters/disk-reader'
@@ -8,7 +9,7 @@ import { DiskWriter } from '../adapters/disk-writer'
const { basename, join } = nodePath
-function onAbort(signal: AbortSignal | undefined, cancel: () => void): () => void {
+function onAbort(signal: AbortLike | undefined, cancel: () => void): () => void {
if (!signal) return () => {}
if (signal.aborted) {
cancel()
@@ -21,7 +22,8 @@ function onAbort(signal: AbortSignal | undefined, cancel: () => void): () => voi
export interface SendFileOptions {
transferId?: string
name?: string
- signal?: AbortSignal
+ signal?: AbortLike
+ notifyPeerOnCancel?: boolean
highWaterMark?: number
onProgress?: (sentBytes: number, totalBytes: number) => void
}
@@ -38,7 +40,9 @@ export async function sendFile(
highWaterMark: opts.highWaterMark,
onProgress: opts.onProgress
})
- const release = onAbort(opts.signal, () => sender.cancel())
+ const release = onAbort(opts.signal, () =>
+ sender.cancel('Transfer cancelled', { notifyPeer: opts.notifyPeerOnCancel !== false })
+ )
try {
return await sender.start()
} finally {
@@ -50,9 +54,10 @@ export async function sendFile(
export interface ReceiveFileOptions {
transferId?: string
expectedSize?: number
- signal?: AbortSignal
+ signal?: AbortLike
resumeBits?: Uint8Array
verifyFullFile?: boolean
+ overwrite?: boolean
onProgress?: (receivedBytes: number, totalBytes: number) => void
onChunkWritten?: (bitmap: Bitmap) => void
}
@@ -62,7 +67,7 @@ export function receiveFile(
channel: DriveChannel,
opts: ReceiveFileOptions = {}
): Promise<string> {
- const writer = new DiskWriter(targetPath)
+ const writer = new DiskWriter(targetPath, { overwrite: opts.overwrite })
const receiver = new ReceiverSession(writer, channel, {
transferId: opts.transferId,
expectedSize: opts.expectedSize,
@@ -71,7 +76,9 @@ export function receiveFile(
onProgress: opts.onProgress,
onChunkWritten: opts.onChunkWritten
})
- const release = onAbort(opts.signal, () => receiver.cancel())
+ const release = onAbort(opts.signal, () => {
+ receiver.cancel()
+ })
return receiver.receive().finally(release)
}
diff --git a/packages/drive/src/blake2b-wasm.d.ts b/packages/drive/src/blake2b-wasm.d.ts
new file mode 100644
index 0000000..5c5ed74
--- /dev/null
+++ b/packages/drive/src/blake2b-wasm.d.ts
@@ -0,0 +1,12 @@
+declare module 'blake2b-wasm' {
+ interface Blake2bHash {
+ update(input: Uint8Array): Blake2bHash
+ digest(encoding: 'hex'): string
+ digest(): Uint8Array
+ }
+ function blake2b(outLength: number): Blake2bHash
+ namespace blake2b {
+ function ready(cb: (err: Error | null) => void): void
+ }
+ export = blake2b
+}
diff --git a/packages/drive/src/engine/bitmap.ts b/packages/drive/src/engine/bitmap.ts
index eddd9e6..edce4bb 100644
--- a/packages/drive/src/engine/bitmap.ts
+++ b/packages/drive/src/engine/bitmap.ts
@@ -7,8 +7,10 @@ export class Bitmap {
this.size = size
const byteLength = Math.ceil(size / 8)
if (bits) {
- if (bits.length < byteLength) throw new Error('Bitmap bits too short for size')
- this.bits = bits.slice(0, byteLength)
+ if (bits.length !== byteLength) {
+ throw new Error(`Bitmap is ${bits.length} bytes, expected ${byteLength}`)
+ }
+ this.bits = bits.slice()
for (let i = 0; i < size; i++) {
if (this.get(i)) this.setBits++
}
diff --git a/packages/drive/src/engine/errors.ts b/packages/drive/src/engine/errors.ts
new file mode 100644
index 0000000..01da8fa
--- /dev/null
+++ b/packages/drive/src/engine/errors.ts
@@ -0,0 +1,10 @@
+export class IntegrityError extends Error {
+ constructor(message: string) {
+ super(message)
+ this.name = 'IntegrityError'
+ }
+}
+
+export const PEER_SILENCE_TIMEOUT_MS = 60_000
+
+export const PROGRESS_STEP_BYTES = 2 * 1024 * 1024
diff --git a/packages/drive/src/engine/hash.test.ts b/packages/drive/src/engine/hash.test.ts
index 49228c3..e3276d2 100644
--- a/packages/drive/src/engine/hash.test.ts
+++ b/packages/drive/src/engine/hash.test.ts
@@ -1,35 +1,62 @@
import { describe, it, expect } from 'vitest'
-import { hashChunk, createHasher } from './hash'
+import { hashChunk, createHasher, createFileHasher, ready } from './hash'
-describe('hashChunk', () => {
- it('is deterministic for the same bytes', () => {
- const data = new Uint8Array([1, 2, 3, 4, 5])
- expect(hashChunk(data)).toBe(hashChunk(data.slice()))
+function bytes(n: number): Uint8Array {
+ const out = new Uint8Array(n)
+ for (let i = 0; i < n; i++) out[i] = (i * 31 + 7) & 0xff
+ return out
+}
+
+const VECTORS: [number, string][] = [
+ [0, '0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8'],
+ [1, '873e4fe9e41e924911bba3ec53ff4782efc8c0f244fb75c879f8a4328d0142ca'],
+ [63, '0745452c1dfca7e1ea6051fc7112a622b0131377e4ab08825d5b8223b37e0a8a'],
+ [64, '7f6ac9517a5a27b6a059aca25d95f3a144115a759b71ee3990df65191573c5e2'],
+ [65, 'cbcc0b56230a8c21aaa9ce88b5631ebd9dbd1aebd009a765f77f0ce0b9793023'],
+ [1024, 'acb61fad7b8eb85172fe559f00c492e1398fc34ab8d0109ac52b150bf3e514be'],
+ [200 * 1024, '5154304015b8b37f4abdedff1fbd6e65f4fa0706e0bccd8c33683f1f7bee2a97']
+]
+
+describe('chunk hashing', () => {
+ it('matches known BLAKE2b-256 digests', async () => {
+ await ready()
+ for (const [n, expected] of VECTORS) {
+ expect(hashChunk(bytes(n))).toBe(expected)
+ }
})
- it('differs for different bytes', () => {
- expect(hashChunk(new Uint8Array([1, 2, 3]))).not.toBe(hashChunk(new Uint8Array([1, 2, 4])))
+ it('streams in pieces to the same digest as one shot', async () => {
+ await ready()
+ const data = bytes(5000)
+ const streaming = createHasher()
+ streaming.update(data.subarray(0, 1000))
+ streaming.update(data.subarray(1000))
+ expect(streaming.digest()).toBe(hashChunk(data))
})
- it('returns a 32-byte (64 hex char) digest', () => {
- expect(hashChunk(new Uint8Array([0]))).toMatch(/^[0-9a-f]{64}$/)
+ it('folds chunk hashes into a stable file root', async () => {
+ await ready()
+ const root = createFileHasher()
+ root.add(hashChunk(bytes(64)))
+ root.add(hashChunk(bytes(65)))
+
+ const again = createFileHasher()
+ again.add(VECTORS[3][1])
+ again.add(VECTORS[4][1])
+
+ expect(root.digest()).toBe(again.digest())
})
})
-describe('createHasher', () => {
- it('matches the one-shot hash when fed the whole buffer', () => {
- const data = new Uint8Array([10, 20, 30, 40, 50, 60])
- const h = createHasher()
- h.update(data)
- expect(h.digest()).toBe(hashChunk(data))
+describe('js fallback', () => {
+ it('produces the same digests as wasm', async () => {
+ const js = (await import('blake2b')).default
+ for (const [n, expected] of VECTORS) {
+ expect(js(32).update(bytes(n)).digest('hex')).toBe(expected)
+ }
})
- it('matches regardless of how bytes are split across updates', () => {
- const data = new Uint8Array([10, 20, 30, 40, 50, 60])
- const h = createHasher()
- h.update(data.subarray(0, 2))
- h.update(data.subarray(2, 5))
- h.update(data.subarray(5))
- expect(h.digest()).toBe(hashChunk(data))
+ it('hashes before ready() has been awaited', () => {
+ expect(hashChunk(bytes(64))).toBe(VECTORS[3][1])
})
})
diff --git a/packages/drive/src/engine/hash.ts b/packages/drive/src/engine/hash.ts
index c7b0592..6d9dffa 100644
--- a/packages/drive/src/engine/hash.ts
+++ b/packages/drive/src/engine/hash.ts
@@ -1,9 +1,21 @@
-import blake2b from 'blake2b'
+import blake2bJs from 'blake2b'
+import blake2bWasm from 'blake2b-wasm'
const DIGEST_BYTES = 32
+let create = blake2bJs
+
+export function ready(): Promise<boolean> {
+ return new Promise((resolve) => {
+ blake2bWasm.ready((err) => {
+ if (!err) create = blake2bWasm
+ resolve(!err)
+ })
+ })
+}
+
export function hashChunk(data: Uint8Array): string {
- return blake2b(DIGEST_BYTES).update(data).digest('hex')
+ return create(DIGEST_BYTES).update(data).digest('hex')
}
export interface StreamingHasher {
@@ -12,7 +24,7 @@ export interface StreamingHasher {
}
export function createHasher(): StreamingHasher {
- const h = blake2b(DIGEST_BYTES)
+ const h = create(DIGEST_BYTES)
return {
update(data) {
h.update(data)
diff --git a/packages/drive/src/engine/loopback.test.ts b/packages/drive/src/engine/loopback.test.ts
index 87fd723..69b4c96 100644
--- a/packages/drive/src/engine/loopback.test.ts
+++ b/packages/drive/src/engine/loopback.test.ts
@@ -11,6 +11,8 @@ import { DiskWriter } from '../adapters/disk-writer'
import { createChannelPair } from '../../test/support'
import type {
ChunkHeader,
+ ChunkReader,
+ ChunkWriter,
CompleteMessage,
ControlMessage,
DriveChannel,
@@ -77,7 +79,7 @@ function frames(input: Uint8Array, transferId: string) {
for (let i = 0; i < total; i++) {
const { offset, length } = chunkRange(i, input.length, chunkSize)
const data = input.slice(offset, offset + length)
- list.push({ header: { transferId, index: i, hash: hashChunk(data) }, data })
+ list.push({ header: { transferId, index: i }, data })
}
return { chunkSize, total, list }
}
@@ -173,6 +175,29 @@ describe('full sender ↔ receiver loopback', () => {
await sender.close()
expect(lastReceived).toBe(input.length)
})
+
+ it('reports absolute progress when the peer only needs the tail', async () => {
+ const input = pseudoRandom(200 * 1024)
+ const src = join(dir, 'src.bin')
+ await writeFile(src, input)
+
+ const { channel, sent, deliverMessage } = controlledChannel()
+ const progress: number[] = []
+ const sender = new SenderSession(new DiskReader(src), channel, {
+ transferId: 't',
+ name: 'file.bin',
+ onProgress: (bytes) => progress.push(bytes)
+ })
+ sender.start().catch((err) => console.error('test setup failed', err))
+ await waitUntil(() => sent.some((m) => m.type === 'start'))
+
+ const total = chunkCount(input.length, CHUNK_64K)
+ deliverMessage({ type: 'need', transferId: 't', indices: [total - 1] })
+ await waitUntil(() => progress.length > 0)
+ await sender.close()
+
+ expect(progress.at(-1)).toBe(input.length)
+ })
})
describe('receiver robustness', () => {
@@ -237,11 +262,9 @@ describe('receiver robustness', () => {
size: input.length,
chunkSize: CHUNK_64K
})
- const corrupted = list[0].data.slice()
- corrupted[0] ^= 0xff
- deliverChunk(list[0].header, corrupted)
+ deliverChunk(list[0].header, list[0].data.slice(0, 8))
- await expect(done).rejects.toThrow(/hash verification/)
+ await expect(done).rejects.toThrow(/length/)
expect(sent.some((m) => m.type === 'cancel')).toBe(true)
})
@@ -265,7 +288,7 @@ describe('receiver robustness', () => {
expect(sent.some((m) => m.type === 'cancel')).toBe(false)
})
- it('rejects a chunk that fails hash verification', async () => {
+ it('rejects a chunk whose length does not match its slot', async () => {
const input = pseudoRandom(200 * 1024)
const dst = join(dir, 'dst.bin')
const { list } = frames(input, 't')
@@ -281,12 +304,10 @@ describe('receiver robustness', () => {
size: input.length,
chunkSize: CHUNK_64K
})
- const corrupted = list[0].data.slice()
- corrupted[0] ^= 0xff
- deliverChunk(list[0].header, corrupted)
+ deliverChunk(list[0].header, list[0].data.slice(0, 8))
- await expect(done).rejects.toThrow(/hash verification/)
- await expect(stat(`${dst}.part`)).rejects.toThrow()
+ await expect(done).rejects.toThrow(/length/)
+ await expect(stat(dst)).rejects.toThrow()
})
it('rejects a chunk whose length is wrong', async () => {
@@ -319,7 +340,7 @@ describe('resume', () => {
const first = controlledChannel()
const receiver1 = new ReceiverSession(new DiskWriter(dst), first.channel, { transferId: 't' })
- receiver1.receive().catch(() => {})
+ receiver1.receive().catch((err) => console.error('test setup failed', err))
first.deliverMessage({
type: 'start',
transferId: 't',
@@ -365,7 +386,7 @@ describe('resume', () => {
const first = controlledChannel()
const receiver1 = new ReceiverSession(new DiskWriter(dst), first.channel, { transferId: 't' })
- receiver1.receive().catch(() => {})
+ receiver1.receive().catch((err) => console.error('test setup failed', err))
first.deliverMessage({
type: 'start',
transferId: 't',
@@ -408,7 +429,7 @@ describe('resume', () => {
const first = controlledChannel()
const receiver1 = new ReceiverSession(new DiskWriter(dst), first.channel, { transferId: 't' })
- receiver1.receive().catch(() => {})
+ receiver1.receive().catch((err) => console.error('test setup failed', err))
first.deliverMessage({
type: 'start',
transferId: 't',
@@ -443,7 +464,7 @@ describe('resume', () => {
second.deliverMessage({ type: 'complete', transferId: 't', fileHash: fileRoot(input) })
await expect(done).rejects.toThrow(/hash mismatch/)
- await expect(stat(`${dst}.part`)).rejects.toThrow()
+ await expect(stat(dst)).rejects.toThrow()
})
})
@@ -464,9 +485,9 @@ describe('sender full-file hash', () => {
close: () => {}
}
const sender = new SenderSession(new DiskReader(src), channel, { transferId: 't', name: 'f' })
- sender.start().catch(() => {})
+ sender.start().catch((err) => console.error('test setup failed', err))
await waitUntil(() => sent.some((m) => m.type === 'start'))
- msgHandler!({ type: 'need', transferId: 't', indices: [2, 3] })
+ msgHandler!({ type: 'need', transferId: 't', indices: [2, 3], verify: true })
await waitUntil(() => sent.some((m) => m.type === 'complete'))
await sender.close()
@@ -538,3 +559,115 @@ describe('hostile input', () => {
await sender.close()
})
})
+
+describe('hash reuse is limited to the current session', () => {
+ it('a full send reads each chunk once and computes no hash', async () => {
+ const input = pseudoRandom(200 * 1024)
+ const src = join(dir, 'src.bin')
+ await writeFile(src, input)
+ const { total } = frames(input, 't')
+
+ const disk = new DiskReader(src)
+ let reads = 0
+ const counting: ChunkReader = {
+ size: () => disk.size(),
+ read: (offset, length) => {
+ reads++
+ return disk.read(offset, length)
+ },
+ close: () => disk.close()
+ }
+
+ const { channel, sent, deliverMessage } = controlledChannel()
+ const sender = new SenderSession(counting, channel, { transferId: 't', name: 'f' })
+ sender.start().catch((err) => console.error('test setup failed', err))
+ await waitUntil(() => sent.some((m) => m.type === 'start'))
+ deliverMessage({ type: 'need', transferId: 't', indices: range(0, total) })
+ await waitUntil(() => sent.some((m) => m.type === 'complete'))
+
+ const complete = sent.find((m): m is CompleteMessage => m.type === 'complete')!
+ expect(complete.fileHash).toBe(null)
+ expect(reads).toBe(total)
+ })
+
+ it('a resumed send re-reads the chunks it did not send, so the hash describes the file now', async () => {
+ const input = pseudoRandom(200 * 1024)
+ const src = join(dir, 'src.bin')
+ await writeFile(src, input)
+ const { total } = frames(input, 't')
+
+ const { channel, sent, deliverMessage } = controlledChannel()
+ const sender = new SenderSession(new DiskReader(src), channel, { transferId: 't', name: 'f' })
+ sender.start().catch((err) => console.error('test setup failed', err))
+ await waitUntil(() => sent.some((m) => m.type === 'start'))
+ deliverMessage({ type: 'need', transferId: 't', indices: [total - 1], verify: true })
+ await waitUntil(() => sent.some((m) => m.type === 'complete'))
+
+ const complete = sent.find((m): m is CompleteMessage => m.type === 'complete')!
+ expect(complete.fileHash).toBe(fileRoot(input))
+ })
+
+ it('detects a partial file corrupted between attempts', async () => {
+ const input = pseudoRandom(200 * 1024)
+ const dst = join(dir, 'dst.bin')
+ const { list, total } = frames(input, 't')
+
+ const first = controlledChannel()
+ let bits = new Uint8Array()
+ const receiver1 = new ReceiverSession(new DiskWriter(dst), first.channel, {
+ transferId: 't',
+ onChunkWritten: (bitmap) => {
+ bits = bitmap.serialize().slice()
+ }
+ })
+ receiver1.receive().catch((err) => console.error('test setup failed', err))
+ first.deliverMessage({
+ type: 'start',
+ transferId: 't',
+ name: 'f',
+ size: input.length,
+ chunkSize: CHUNK_64K
+ })
+ first.deliverChunk(list[0].header, list[0].data)
+ first.deliverChunk(list[1].header, list[1].data)
+ await waitUntil(() => (receiver1.received?.count() ?? 0) === 2)
+
+ const fh = await open(`${dst}.part`, 'r+')
+ await fh.write(new Uint8Array(CHUNK_64K), 0, CHUNK_64K, 0)
+ await fh.close()
+
+ const inner = new DiskWriter(dst)
+ let readBacks = 0
+ const counting: ChunkWriter = {
+ allocate: (size) => inner.allocate(size),
+ write: (offset, data) => inner.write(offset, data),
+ readBack: (offset, length) => {
+ readBacks++
+ return inner.readBack(offset, length)
+ },
+ finalize: () => inner.finalize(),
+ abort: () => inner.abort()
+ }
+
+ const second = controlledChannel()
+ const receiver2 = new ReceiverSession(counting, second.channel, {
+ transferId: 't',
+ resumeBits: bits
+ })
+ const done = receiver2.receive()
+ second.deliverMessage({
+ type: 'start',
+ transferId: 't',
+ name: 'f',
+ size: input.length,
+ chunkSize: CHUNK_64K
+ })
+ await waitUntil(() => second.sent.some((m) => m.type === 'need'))
+ for (let i = 2; i < total; i++) second.deliverChunk(list[i].header, list[i].data)
+ second.deliverMessage({ type: 'complete', transferId: 't', fileHash: fileRoot(input) })
+
+ await expect(done).rejects.toThrow(/mismatch/)
+ expect(readBacks).toBe(total)
+ await expect(stat(dst)).rejects.toThrow()
+ })
+})
diff --git a/packages/drive/src/engine/paths.ts b/packages/drive/src/engine/paths.ts
new file mode 100644
index 0000000..2ff91d9
--- /dev/null
+++ b/packages/drive/src/engine/paths.ts
@@ -0,0 +1,24 @@
+import path from '#path'
+
+const MAX_NAME_VARIANTS = 999
+
+function numberedPath(filePath: string, n: number): string {
+ const dir = path.dirname(filePath)
+ const name = path.basename(filePath)
+ const dot = name.lastIndexOf('.')
+ const base = dot > 0 ? name.slice(0, dot) : name
+ const ext = dot > 0 ? name.slice(dot) : ''
+ return path.join(dir, `${base} (${n})${ext}`)
+}
+
+export async function firstFreePath(
+ filePath: string,
+ isFree: (candidate: string) => boolean | Promise<boolean>
+): Promise<string> {
+ if (await isFree(filePath)) return filePath
+ for (let n = 1; n <= MAX_NAME_VARIANTS; n++) {
+ const candidate = numberedPath(filePath, n)
+ if (await isFree(candidate)) return candidate
+ }
+ return filePath
+}
diff --git a/packages/drive/src/engine/receiver.ts b/packages/drive/src/engine/receiver.ts
index a1ed7f8..96642dd 100644
--- a/packages/drive/src/engine/receiver.ts
+++ b/packages/drive/src/engine/receiver.ts
@@ -2,12 +2,20 @@ import type { ChunkWriter, DriveChannel, ChunkHeader, ControlMessage } from './t
import { selectChunkSize, chunkCount, chunkRange } from './chunker'
import { hashChunk, createFileHasher } from './hash'
import { Bitmap } from './bitmap'
+import { IntegrityError, PEER_SILENCE_TIMEOUT_MS, PROGRESS_STEP_BYTES } from './errors'
+import { Timeout } from './timeout'
+
+interface CancelOptions {
+ notifyPeer?: boolean
+}
export interface ReceiverOptions {
transferId?: string
expectedSize?: number
resumeBits?: Uint8Array
verifyFullFile?: boolean
+ stallTimeoutMs?: number
+ progressStepBytes?: number
onProgress?: (receivedBytes: number, totalBytes: number) => void
onChunkWritten?: (bitmap: Bitmap) => void
}
@@ -21,24 +29,43 @@ export class ReceiverSession {
private chunkSize = 0
private bitmap: Bitmap | null = null
private receivedBytes = 0
+ private reportedBytes = 0
private resumed = false
private transferId: string | null
private settled = false
+ private cancelling = false
private settle!: { resolve: (savedTo: string) => void; reject: (err: Error) => void }
private readonly done: Promise<string>
private tail: Promise<void> = Promise.resolve()
+ private readonly silence: Timeout
constructor(writer: ChunkWriter, channel: DriveChannel, opts: ReceiverOptions) {
this.writer = writer
this.channel = channel
this.opts = opts
this.transferId = opts.transferId ?? null
+ const silenceMs = opts.stallTimeoutMs ?? PEER_SILENCE_TIMEOUT_MS
+ this.silence = new Timeout(silenceMs, () =>
+ this.enqueue(() => this.fail(new Error(`No data from sender for ${silenceMs}ms`)))
+ )
this.done = new Promise<string>((resolve, reject) => {
this.settle = { resolve, reject }
})
this.done.catch(() => {})
- this.channel.onMessage((message) => this.onMessage(message))
- this.channel.onChunk((header, data) => this.enqueue(() => this.onChunk(header, data)))
+ this.channel.onMessage((message) => {
+ this.restartSilenceTimer()
+ this.onMessage(message)
+ })
+ this.channel.onChunk((header, data) => {
+ this.restartSilenceTimer()
+ this.enqueue(() => this.onChunk(header, data))
+ })
+ this.restartSilenceTimer()
+ }
+
+ private restartSilenceTimer(): void {
+ if (this.settled) return
+ this.silence.restart()
}
private enqueue(task: () => Promise<void>): void {
@@ -67,31 +94,52 @@ export class ReceiverSession {
break
case 'cancel':
this.enqueue(() =>
- this.fail(new Error(message.reason ?? 'Transfer cancelled by sender'), false)
+ this.fail(new Error(message.reason ?? 'Transfer cancelled by sender'), {
+ notifyPeer: false
+ })
)
break
}
}
- private validGeometry(size: number, chunkSize: number): boolean {
+ private isValidGeometry(size: number, chunkSize: number): boolean {
return Number.isSafeInteger(size) && size >= 0 && chunkSize === selectChunkSize(size)
}
private async onStart(size: number, chunkSize: number): Promise<void> {
- if (this.settled) return
- if (!this.validGeometry(size, chunkSize)) {
- throw new Error(`Rejected transfer geometry: size=${size} chunkSize=${chunkSize}`)
+ if (this.settled || this.cancelling) return
+ if (!this.isValidGeometry(size, chunkSize)) {
+ throw new IntegrityError(`Rejected transfer geometry: size=${size} chunkSize=${chunkSize}`)
}
const expected = this.opts.expectedSize
if (expected !== undefined && size !== expected) {
- throw new Error(`Sender announced ${size} bytes, expected ${expected}`)
+ throw new IntegrityError(`Sender announced ${size} bytes, expected ${expected}`)
}
+ if (this.bitmap) {
+ if (size !== this.size || chunkSize !== this.chunkSize) {
+ throw new IntegrityError(`Sender re-announced ${size}/${chunkSize} mid-transfer`)
+ }
+ this.channel.send({
+ type: 'need',
+ transferId: this.transferId!,
+ indices: this.bitmap.missing(),
+ verify: this.needsVerification()
+ })
+ return
+ }
+
this.size = size
this.chunkSize = chunkSize
const total = chunkCount(size, chunkSize)
- this.bitmap = this.opts.resumeBits
- ? Bitmap.deserialize(total, this.opts.resumeBits)
- : new Bitmap(total)
+ try {
+ this.bitmap = this.opts.resumeBits
+ ? Bitmap.deserialize(total, this.opts.resumeBits)
+ : new Bitmap(total)
+ } catch (err) {
+ throw new IntegrityError(
+ `Resume state does not match this file: ${err instanceof Error ? err.message : String(err)}`
+ )
+ }
this.resumed = this.bitmap.count() > 0
for (let i = 0; i < total; i++) {
@@ -102,50 +150,62 @@ export class ReceiverSession {
this.channel.send({
type: 'need',
transferId: this.transferId!,
- indices: this.bitmap.missing()
+ indices: this.bitmap.missing(),
+ verify: this.needsVerification()
})
}
+ private needsVerification(): boolean {
+ return this.opts.verifyFullFile === true || this.resumed
+ }
+
private async onChunk(header: ChunkHeader, data: Uint8Array): Promise<void> {
- if (this.settled) return
+ if (this.settled || this.cancelling) return
if (header.transferId !== this.transferId) return
const bitmap = this.bitmap
- if (!bitmap) throw new Error('Received chunk before start')
+ if (!bitmap) return
if (!Number.isInteger(header.index) || header.index < 0 || header.index >= bitmap.size) {
throw new Error(`Chunk index ${header.index} out of range`)
}
if (bitmap.get(header.index)) return
const { offset, length } = chunkRange(header.index, this.size, this.chunkSize)
+
if (data.length !== length) {
throw new Error(`Chunk ${header.index} length ${data.length}, expected ${length}`)
}
- if (hashChunk(data) !== header.hash) {
- throw new Error(`Chunk ${header.index} failed hash verification`)
- }
await this.writer.write(offset, data)
bitmap.set(header.index)
this.receivedBytes += length
this.opts.onChunkWritten?.(bitmap)
+ this.reportProgress(bitmap.allSet())
+ }
+
+ private reportProgress(force: boolean): void {
+ const step = this.opts.progressStepBytes ?? PROGRESS_STEP_BYTES
+ if (!force && this.receivedBytes - this.reportedBytes < step) return
+ this.reportedBytes = this.receivedBytes
this.opts.onProgress?.(this.receivedBytes, this.size)
}
private async onComplete(fileHash: string | null): Promise<void> {
- if (this.settled) return
+ if (this.settled || this.cancelling) return
+ this.silence.stop()
const bitmap = this.bitmap
if (!bitmap) throw new Error('Received complete before start')
if (!bitmap.allSet()) {
throw new Error(`Transfer incomplete: ${bitmap.count()}/${bitmap.size} chunks`)
}
- if (this.opts.verifyFullFile || this.resumed) {
- if (!fileHash) throw new Error('Missing file hash: cannot verify the assembled file')
+ if (this.needsVerification()) {
+ if (!fileHash) throw new IntegrityError('Missing file hash: cannot verify the assembled file')
await this.verifyFullFile(fileHash)
}
const savedTo = await this.writer.finalize()
this.settled = true
+ this.silence.stop()
try {
this.channel.send({ type: 'ack', transferId: this.transferId!, savedTo })
} catch {}
@@ -158,22 +218,26 @@ export class ReceiverSession {
for (let i = 0; i < total; i++) {
const { offset, length } = chunkRange(i, this.size, this.chunkSize)
const bytes = await this.writer.readBack(offset, length)
- if (!bytes) throw new Error('Full-file verification could not read back file')
+ if (!bytes) throw new IntegrityError('Full-file verification could not read back file')
root.add(hashChunk(bytes))
}
- if (root.digest() !== expected) throw new Error('Full-file hash mismatch')
+ if (root.digest() !== expected) throw new IntegrityError('Full-file hash mismatch')
}
cancel(reason = 'Transfer cancelled'): void {
+ if (this.settled || this.cancelling) return
+ this.cancelling = true
+ this.silence.stop()
this.enqueue(() => this.fail(new Error(reason)))
}
- private async fail(err: Error, notifyPeer = true): Promise<void> {
+ private async fail(err: Error, { notifyPeer = true }: CancelOptions = {}): Promise<void> {
if (this.settled) return
this.settled = true
+ this.silence.stop()
if (notifyPeer && this.transferId !== null) {
try {
- this.channel.send({ type: 'cancel', transferId: this.transferId })
+ this.channel.send({ type: 'cancel', transferId: this.transferId, reason: err.message })
} catch {}
}
try {
diff --git a/packages/drive/src/engine/sender.ts b/packages/drive/src/engine/sender.ts
index ba62bcf..6e28fb6 100644
--- a/packages/drive/src/engine/sender.ts
+++ b/packages/drive/src/engine/sender.ts
@@ -1,11 +1,19 @@
import type { ChunkReader, DriveChannel, ControlMessage } from './types'
import { selectChunkSize, chunkCount, chunkRange } from './chunker'
import { hashChunk, createFileHasher } from './hash'
+import { PEER_SILENCE_TIMEOUT_MS, PROGRESS_STEP_BYTES } from './errors'
+import { Timeout } from './timeout'
+
+interface CancelOptions {
+ notifyPeer?: boolean
+}
export interface SenderOptions {
transferId: string
name: string
highWaterMark?: number
+ ackTimeoutMs?: number
+ progressStepBytes?: number
onProgress?: (sentBytes: number, totalBytes: number) => void
}
@@ -22,8 +30,10 @@ export class SenderSession {
private chunkSize = 0
private totalChunks = 0
private started = false
+ private announced = false
private sending = false
private settled = false
+ private readonly ackTimeout: Timeout
private settle!: { resolve: (savedTo: string) => void; reject: (err: Error) => void }
constructor(reader: ChunkReader, channel: DriveChannel, opts: SenderOptions) {
@@ -37,6 +47,10 @@ export class SenderSession {
this.done = new Promise<string>((resolve, reject) => {
this.settle = { resolve, reject }
})
+ const ackMs = opts.ackTimeoutMs ?? PEER_SILENCE_TIMEOUT_MS
+ this.ackTimeout = new Timeout(ackMs, () =>
+ this.fail(new Error(`Receiver did not acknowledge within ${ackMs}ms`), { notifyPeer: false })
+ )
this.done.catch(() => {})
this.channel.onMessage((message) => this.onMessage(message))
}
@@ -50,6 +64,8 @@ export class SenderSession {
this.chunkSize = selectChunkSize(this.size)
this.totalChunks = chunkCount(this.size, this.chunkSize)
+ if (this.settled) return this.done
+
this.channel.send({
type: 'start',
transferId: this.opts.transferId,
@@ -57,6 +73,7 @@ export class SenderSession {
size: this.size,
chunkSize: this.chunkSize
})
+ this.announced = true
} catch (err) {
this.fail(err instanceof Error ? err : new Error(String(err)))
}
@@ -68,20 +85,24 @@ export class SenderSession {
if (message.transferId !== this.opts.transferId) return
switch (message.type) {
case 'need':
- this.sendChunks(message.indices).catch((err) => this.fail(err))
+ if (!this.announced) break
+ this.sendChunks(message.indices, message.verify === true).catch((err) => this.fail(err))
break
case 'ack':
if (this.settled) break
this.settled = true
+ this.ackTimeout.stop()
this.settle.resolve(message.savedTo)
break
case 'cancel':
- this.fail(new Error(message.reason ?? 'Transfer cancelled by receiver'), false)
+ this.fail(new Error(message.reason ?? 'Transfer cancelled by receiver'), {
+ notifyPeer: false
+ })
break
}
}
- private validIndices(indices: number[]): boolean {
+ private hasValidIndices(indices: number[]): boolean {
const seen = new Set<number>()
for (const index of indices) {
if (!Number.isInteger(index) || index < 0 || index >= this.totalChunks) return false
@@ -91,46 +112,56 @@ export class SenderSession {
return true
}
- private async sendChunks(indices: number[]): Promise<void> {
+ private async sendChunks(indices: number[], verify: boolean): Promise<void> {
if (this.sending) return
this.sending = true
+ try {
+ if (!this.hasValidIndices(indices)) {
+ this.fail(new Error('Rejected invalid chunk request'))
+ return
+ }
+
+ const step = this.opts.progressStepBytes ?? PROGRESS_STEP_BYTES
+ const pendingBytes = indices.reduce(
+ (total, index) => total + chunkRange(index, this.size, this.chunkSize).length,
+ 0
+ )
+ let sentBytes = this.size - pendingBytes
+ let reportedBytes = sentBytes
+ for (const index of indices) {
+ if (this.settled) return
+ const { offset, length } = chunkRange(index, this.size, this.chunkSize)
+ const data = await this.reader.read(offset, length)
+
+ await this.drain()
+ if (this.settled) return
+ this.channel.sendChunk({ transferId: this.opts.transferId, index }, data)
+
+ sentBytes += data.length
+ if (sentBytes - reportedBytes >= step || sentBytes === this.size) {
+ reportedBytes = sentBytes
+ this.opts.onProgress?.(sentBytes, this.size)
+ }
+ }
- if (!this.validIndices(indices)) {
- this.fail(new Error('Rejected invalid chunk request'))
- return
- }
-
- const inOrderFull = indices.length === this.totalChunks && indices.every((idx, i) => idx === i)
- const root = inOrderFull ? createFileHasher() : null
-
- let sentBytes = 0
- for (const index of indices) {
if (this.settled) return
- const { offset, length } = chunkRange(index, this.size, this.chunkSize)
- const data = await this.reader.read(offset, length)
- const hash = hashChunk(data)
- root?.add(hash)
-
- await this.drain()
- this.channel.sendChunk({ transferId: this.opts.transferId, index, hash }, data)
-
- sentBytes += data.length
- this.opts.onProgress?.(sentBytes, this.size)
+ const fileHash = verify ? await this.computeFileHash() : null
+ if (this.settled) return
+ this.channel.send({
+ type: 'complete',
+ transferId: this.opts.transferId,
+ fileHash
+ })
+ this.ackTimeout.start()
+ } finally {
+ this.sending = false
}
-
- if (this.settled) return
- const fileHash = root ? root.digest() : await this.fileRoot()
- if (this.settled) return
- this.channel.send({
- type: 'complete',
- transferId: this.opts.transferId,
- fileHash
- })
}
- private async fileRoot(): Promise<string> {
+ private async computeFileHash(): Promise<string> {
const root = createFileHasher()
for (let i = 0; i < this.totalChunks; i++) {
+ if (this.settled) throw new Error('Transfer cancelled')
const { offset, length } = chunkRange(i, this.size, this.chunkSize)
root.add(hashChunk(await this.reader.read(offset, length)))
}
@@ -143,13 +174,14 @@ export class SenderSession {
}
}
- cancel(reason = 'Transfer cancelled'): void {
- this.fail(new Error(reason))
+ cancel(reason = 'Transfer cancelled', options: CancelOptions = {}): void {
+ this.fail(new Error(reason), options)
}
- private fail(err: Error, notifyPeer = true): void {
+ private fail(err: Error, { notifyPeer = true }: CancelOptions = {}): void {
if (this.settled) return
this.settled = true
+ this.ackTimeout.stop()
if (notifyPeer) {
try {
this.channel.send({ type: 'cancel', transferId: this.opts.transferId })
diff --git a/packages/drive/src/engine/timeout.ts b/packages/drive/src/engine/timeout.ts
new file mode 100644
index 0000000..206adf4
--- /dev/null
+++ b/packages/drive/src/engine/timeout.ts
@@ -0,0 +1,34 @@
+export class Timeout {
+ private readonly ms: number
+ private readonly onExpire: () => void
+ private timer: ReturnType<typeof setTimeout> | null = null
+
+ constructor(ms: number, onExpire: () => void) {
+ this.ms = ms
+ this.onExpire = onExpire
+ }
+
+ start(): void {
+ if (this.timer) return
+ this.schedule()
+ }
+
+ restart(): void {
+ this.stop()
+ this.schedule()
+ }
+
+ stop(): void {
+ if (!this.timer) return
+ clearTimeout(this.timer)
+ this.timer = null
+ }
+
+ private schedule(): void {
+ this.timer = setTimeout(() => {
+ this.timer = null
+ this.onExpire()
+ }, this.ms)
+ this.timer.unref?.()
+ }
+}
diff --git a/packages/drive/src/engine/types.ts b/packages/drive/src/engine/types.ts
index 7cc8e23..60c28a0 100644
--- a/packages/drive/src/engine/types.ts
+++ b/packages/drive/src/engine/types.ts
@@ -1,3 +1,9 @@
+export interface AbortLike {
+ readonly aborted: boolean
+ addEventListener(type: 'abort', listener: () => void): void
+ removeEventListener(type: 'abort', listener: () => void): void
+}
+
export interface ChunkReader {
size(): Promise<number>
read(offset: number, length: number): Promise<Uint8Array>
@@ -24,7 +30,6 @@ export interface DriveChannel {
export interface ChunkHeader {
transferId: string
index: number
- hash: string
}
export type ControlMessage =
@@ -46,12 +51,13 @@ export interface NeedMessage {
type: 'need'
transferId: string
indices: number[]
+ verify?: boolean
}
export interface CompleteMessage {
type: 'complete'
transferId: string
- fileHash: string
+ fileHash: string | null
}
export interface AckMessage {
diff --git a/packages/drive/src/index.ts b/packages/drive/src/index.ts
index b6d3636..c76db4f 100644
--- a/packages/drive/src/index.ts
+++ b/packages/drive/src/index.ts
@@ -1,8 +1,10 @@
export { SenderSession, type SenderOptions } from './engine/sender'
export { ReceiverSession, type ReceiverOptions } from './engine/receiver'
+export { IntegrityError, PEER_SILENCE_TIMEOUT_MS } from './engine/errors'
export { Bitmap } from './engine/bitmap'
+export { firstFreePath } from './engine/paths'
export { selectChunkSize, chunkCount, chunkRange, type ChunkRange } from './engine/chunker'
-export { hashChunk, createHasher, type StreamingHasher } from './engine/hash'
+export { hashChunk, createHasher, ready, type StreamingHasher } from './engine/hash'
export type {
ChunkReader,
ChunkWriter,
diff --git a/packages/drive/test/restart.test.ts b/packages/drive/test/restart.test.ts
new file mode 100644
index 0000000..a48c3b2
--- /dev/null
+++ b/packages/drive/test/restart.test.ts
@@ -0,0 +1,328 @@
+import { describe, it, expect } from 'vitest'
+import { ReceiverSession } from '../src/engine/receiver'
+import { SenderSession } from '../src/engine/sender'
+import { selectChunkSize, chunkCount, chunkRange } from '../src/engine/chunker'
+import type { ChunkHeader, ChunkWriter, ControlMessage, DriveChannel } from '../src/engine/types'
+
+class MemoryWriter implements ChunkWriter {
+ bytes = new Uint8Array(0)
+ allocations = 0
+
+ async allocate(size: number): Promise<void> {
+ this.allocations++
+ this.bytes = new Uint8Array(size)
+ }
+
+ async write(offset: number, data: Uint8Array): Promise<void> {
+ this.bytes.set(data, offset)
+ }
+
+ async readBack(offset: number, length: number): Promise<Uint8Array | null> {
+ return this.bytes.subarray(offset, offset + length)
+ }
+
+ async finalize(): Promise<string> {
+ return '/saved'
+ }
+
+ async abort(): Promise<void> {}
+}
+
+function loopback() {
+ const sent: ControlMessage[] = []
+ let onMessage: ((m: ControlMessage) => void) | undefined
+ let onChunk: ((h: ChunkHeader, d: Uint8Array) => void) | undefined
+ const channel: DriveChannel = {
+ send: (m) => sent.push(m),
+ sendChunk: (h, d) => onChunk?.(h, d),
+ onMessage: (h) => {
+ onMessage = h
+ },
+ onChunk: (h) => {
+ onChunk = h
+ },
+ bufferedAmount: () => 0,
+ close: () => {}
+ }
+ return {
+ channel,
+ sent,
+ deliver: (m: ControlMessage) => onMessage?.(m)
+ }
+}
+
+describe('sender re-announcing start', () => {
+ it('does not reset receiver progress or double-count bytes', async () => {
+ const size = 4 * 1024 * 1024
+ const chunkSize = selectChunkSize(size)
+ const total = chunkCount(size, chunkSize)
+ const source = new Uint8Array(size).fill(7)
+
+ const writer = new MemoryWriter()
+ const link = loopback()
+ const progress: number[] = []
+ const receiver = new ReceiverSession(writer, link.channel, {
+ transferId: 't1',
+ onProgress: (bytes) => progress.push(bytes)
+ })
+ receiver.receive().catch(() => {})
+
+ link.deliver({ type: 'start', transferId: 't1', name: 'f', size, chunkSize })
+ await new Promise((r) => setTimeout(r, 0))
+
+ const half = Math.floor(total / 2)
+ for (let i = 0; i < half; i++) {
+ const { offset, length } = chunkRange(i, size, chunkSize)
+ const data = source.subarray(offset, offset + length)
+ link.channel.sendChunk({ transferId: 't1', index: i }, data)
+ }
+ await new Promise((r) => setTimeout(r, 0))
+
+ const beforeRestart = progress[progress.length - 1]
+ expect(beforeRestart).toBeLessThanOrEqual(size)
+
+ link.deliver({ type: 'start', transferId: 't1', name: 'f', size, chunkSize })
+ await new Promise((r) => setTimeout(r, 0))
+
+ expect(writer.allocations).toBe(1)
+
+ const needs = link.sent.filter((m) => m.type === 'need')
+ expect(needs).toHaveLength(2)
+ const second = needs[1] as Extract<ControlMessage, { type: 'need' }>
+ expect(second.indices).toHaveLength(total - half)
+ expect(second.indices[0]).toBe(half)
+
+ for (const bytes of progress) expect(bytes).toBeLessThanOrEqual(size)
+ })
+})
+
+describe('sender need handling', () => {
+ it('serves a second need after the first completes', async () => {
+ const size = 8
+ const source = new Uint8Array(size).fill(3)
+ const chunks: number[] = []
+
+ let onMessage: ((m: ControlMessage) => void) | undefined
+ const channel: DriveChannel = {
+ send: () => {},
+ sendChunk: (h) => chunks.push(h.index),
+ onMessage: (h) => {
+ onMessage = h
+ },
+ onChunk: () => {},
+ bufferedAmount: () => 0,
+ close: () => {}
+ }
+
+ const reader = {
+ size: async () => size,
+ read: async (offset: number, length: number) => source.subarray(offset, offset + length),
+ close: async () => {}
+ }
+
+ const sender = new SenderSession(reader, channel, { transferId: 't1', name: 'f' })
+ sender.start().catch(() => {})
+ await new Promise((r) => setTimeout(r, 0))
+
+ onMessage?.({ type: 'need', transferId: 't1', indices: [0] })
+ await new Promise((r) => setTimeout(r, 10))
+ expect(chunks).toEqual([0])
+
+ onMessage?.({ type: 'need', transferId: 't1', indices: [0] })
+ await new Promise((r) => setTimeout(r, 10))
+ expect(chunks).toEqual([0, 0])
+ })
+})
+
+describe('DiskWriter directories', () => {
+ it('creates missing parent directories for nested folder downloads', async () => {
+ const os = await import('os')
+ const p = await import('path')
+ const fsp = await import('fs/promises')
+ const { DiskWriter } = await import('../src/adapters/disk-writer')
+
+ const root = await fsp.mkdtemp(p.join(os.tmpdir(), 'drive-nested-'))
+ const nested = p.join(root, 'MyFolder', 'sub', 'file.bin')
+ const writer = new DiskWriter(nested)
+
+ await writer.allocate(4)
+ await writer.write(0, new Uint8Array([1, 2, 3, 4]))
+ const saved = await writer.finalize()
+
+ expect(saved).toBe(nested)
+ expect(await fsp.readFile(nested)).toEqual(Buffer.from([1, 2, 3, 4]))
+ await fsp.rm(root, { recursive: true, force: true })
+ })
+})
+
+describe('DiskWriter overwrite', () => {
+ it('replaces the target when overwrite is set, uniquifies otherwise', async () => {
+ const os = await import('os')
+ const p = await import('path')
+ const fsp = await import('fs/promises')
+ const { DiskWriter } = await import('../src/adapters/disk-writer')
+
+ const root = await fsp.mkdtemp(p.join(os.tmpdir(), 'drive-ow-'))
+ const target = p.join(root, 'a.bin')
+ await fsp.writeFile(target, 'OLD')
+
+ const uniq = new DiskWriter(target)
+ await uniq.allocate(3)
+ await uniq.write(0, new Uint8Array([1, 2, 3]))
+ expect(await uniq.finalize()).toBe(p.join(root, 'a (1).bin'))
+ expect(await fsp.readFile(target, 'utf8')).toBe('OLD')
+
+ const over = new DiskWriter(target, { overwrite: true })
+ await over.allocate(3)
+ await over.write(0, new Uint8Array([9, 9, 9]))
+ expect(await over.finalize()).toBe(target)
+ expect(await fsp.readFile(target)).toEqual(Buffer.from([9, 9, 9]))
+
+ await fsp.rm(root, { recursive: true, force: true })
+ })
+})
+
+describe('Bitmap length validation', () => {
+ it('rejects a bitmap that is longer than the geometry requires', async () => {
+ const { Bitmap } = await import('../src/engine/bitmap')
+ expect(() => new Bitmap(8, new Uint8Array(1))).not.toThrow()
+ expect(() => new Bitmap(8, new Uint8Array(2))).toThrow(/expected 1/)
+ expect(() => new Bitmap(8, new Uint8Array(0))).toThrow(/expected 1/)
+ })
+})
+
+describe('stall timeout', () => {
+ it('fails a receiver whose peer goes silent instead of hanging forever', async () => {
+ const writer = new MemoryWriter()
+ const link = loopback()
+ const receiver = new ReceiverSession(writer, link.channel, {
+ transferId: 't1',
+ stallTimeoutMs: 40
+ })
+ const settled = receiver.receive().then(
+ () => 'resolved',
+ (err: Error) => err.message
+ )
+
+ link.deliver({ type: 'start', transferId: 't1', name: 'f', size: 1024, chunkSize: 65536 })
+ await new Promise((r) => setTimeout(r, 10))
+
+ expect(await settled).toMatch(/No data from sender/)
+ })
+
+ it('does not fire while chunks keep arriving', async () => {
+ const size = 4096
+ const chunkSize = selectChunkSize(size)
+ const total = chunkCount(size, chunkSize)
+ const source = new Uint8Array(size).fill(2)
+
+ const writer = new MemoryWriter()
+ const link = loopback()
+ const receiver = new ReceiverSession(writer, link.channel, {
+ transferId: 't1',
+ stallTimeoutMs: 60
+ })
+ const settled = receiver.receive().then(
+ () => 'resolved',
+ (err: Error) => err.message
+ )
+
+ link.deliver({ type: 'start', transferId: 't1', name: 'f', size, chunkSize })
+ for (let i = 0; i < total; i++) {
+ await new Promise((r) => setTimeout(r, 40))
+ const { offset, length } = chunkRange(i, size, chunkSize)
+ const data = source.subarray(offset, offset + length)
+ link.channel.sendChunk({ transferId: 't1', index: i }, data)
+ }
+ await new Promise((r) => setTimeout(r, 10))
+ link.deliver({ type: 'complete', transferId: 't1', fileHash: '' })
+
+ expect(await settled).toBe('resolved')
+ })
+})
+
+describe('partial preservation', () => {
+ it('does not tag a premature complete as an integrity failure', async () => {
+ const writer = new MemoryWriter()
+ const link = loopback()
+ const receiver = new ReceiverSession(writer, link.channel, { transferId: 't1' })
+ const settled = receiver.receive().then(
+ () => null,
+ (err: Error) => err
+ )
+
+ link.deliver({ type: 'start', transferId: 't1', name: 'f', size: 4096, chunkSize: 65536 })
+ await new Promise((r) => setTimeout(r, 0))
+ link.deliver({ type: 'complete', transferId: 't1', fileHash: '' })
+
+ const err = await settled
+ expect(err?.message).toMatch(/incomplete/)
+ expect(err?.name).not.toBe('IntegrityError')
+ })
+})
+
+describe('progress reporting', () => {
+ it('does not emit one event per chunk', async () => {
+ const size = 16 * 1024 * 1024
+ const chunkSize = selectChunkSize(size)
+ const total = chunkCount(size, chunkSize)
+ const source = new Uint8Array(size).fill(5)
+
+ const writer = new MemoryWriter()
+ const link = loopback()
+ const ticks: number[] = []
+ const receiver = new ReceiverSession(writer, link.channel, {
+ transferId: 't1',
+ onProgress: (bytes) => ticks.push(bytes)
+ })
+ receiver.receive().catch(() => {})
+
+ link.deliver({ type: 'start', transferId: 't1', name: 'f', size, chunkSize })
+ await new Promise((r) => setTimeout(r, 0))
+ for (let i = 0; i < total; i++) {
+ const { offset, length } = chunkRange(i, size, chunkSize)
+ link.channel.sendChunk(
+ { transferId: 't1', index: i },
+ source.subarray(offset, offset + length)
+ )
+ }
+ await new Promise((r) => setTimeout(r, 20))
+
+ expect(total).toBeGreaterThan(20)
+ expect(ticks.length).toBeLessThan(total)
+ expect(ticks[ticks.length - 1]).toBe(size)
+ })
+})
+
+describe('stale chunks from a superseded send', () => {
+ it('ignores chunks that arrive before this session knows the geometry', async () => {
+ const writer = new MemoryWriter()
+ const link = loopback()
+ const receiver = new ReceiverSession(writer, link.channel, { transferId: 't1' })
+ const settled = receiver.receive().then(
+ () => 'resolved',
+ (err: Error) => err.message
+ )
+
+ const size = 4096
+ const chunkSize = selectChunkSize(size)
+ const source = new Uint8Array(size).fill(1)
+
+ link.channel.sendChunk({ transferId: 't1', index: 0 }, source.subarray(0, chunkSize))
+ await new Promise((r) => setTimeout(r, 0))
+
+ link.deliver({ type: 'start', transferId: 't1', name: 'f', size, chunkSize })
+ await new Promise((r) => setTimeout(r, 0))
+ for (let i = 0; i < chunkCount(size, chunkSize); i++) {
+ const { offset, length } = chunkRange(i, size, chunkSize)
+ link.channel.sendChunk(
+ { transferId: 't1', index: i },
+ source.subarray(offset, offset + length)
+ )
+ }
+ await new Promise((r) => setTimeout(r, 0))
+ link.deliver({ type: 'complete', transferId: 't1', fileHash: '' })
+
+ expect(await settled).toBe('resolved')
+ })
+})
diff --git a/packages/drive/test/transfer.test.ts b/packages/drive/test/transfer.test.ts
index 8521f12..90315be 100644
--- a/packages/drive/test/transfer.test.ts
+++ b/packages/drive/test/transfer.test.ts
@@ -5,7 +5,7 @@ import { join } from 'node:path'
import { SenderSession } from '../src/engine/sender'
import { ReceiverSession } from '../src/engine/receiver'
import { DiskReader } from '../src/adapters/disk-reader'
-import { DiskWriter } from '../src/adapters/disk-writer'
+import { DiskWriter, discardPartial } from '../src/adapters/disk-writer'
import { createChannelPair } from './support'
let dir = ''
@@ -70,7 +70,7 @@ describe('expectedSize', () => {
})
describe('cancel', () => {
- it('stops the sender mid-flight and leaves no partial file behind', async () => {
+ it('stops the sender mid-flight and keeps the partial for resuming', async () => {
dir = await mkdtemp(join(tmpdir(), 'drive-cancel-'))
const src = join(dir, 'input.bin')
const dst = join(dir, 'output.bin')
@@ -99,6 +99,9 @@ describe('cancel', () => {
expect(results[1].status).toBe('rejected')
expect(sent.length).toBeLessThan(16)
await expect(stat(dst)).rejects.toThrow()
+ expect((await stat(`${dst}.part`)).size).toBeGreaterThan(0)
+
+ await discardPartial(dst)
await expect(stat(`${dst}.part`)).rejects.toThrow()
})
@@ -145,3 +148,29 @@ describe('unreadable source', () => {
await expect(stat(dst)).rejects.toThrow()
})
})
+
+describe('finalize safety', () => {
+ it('never overwrites a file that appeared at the target during the transfer', async () => {
+ dir = await mkdtemp(join(tmpdir(), 'drive-clobber-'))
+ const src = join(dir, 'input.bin')
+ const dst = join(dir, 'output.bin')
+ const input = new Uint8Array(4096).fill(3)
+ await writeFile(src, input)
+
+ const [senderChannel, receiverChannel] = createChannelPair()
+ const receiver = new ReceiverSession(new DiskWriter(dst), receiverChannel, { transferId: 'x1' })
+ const sender = new SenderSession(new DiskReader(src), senderChannel, {
+ transferId: 'x1',
+ name: 'output.bin'
+ })
+
+ await writeFile(dst, 'a file the user created meanwhile')
+
+ const [savedTo] = await Promise.all([receiver.receive(), sender.start()])
+ await sender.close()
+
+ expect(savedTo).not.toBe(dst)
+ expect(await readFile(dst, 'utf8')).toBe('a file the user created meanwhile')
+ expect(Buffer.from(await readFile(savedTo)).equals(Buffer.from(input))).toBe(true)
+ })
+})
diff --git a/packages/locales/src/locales/de-DE/receive.json b/packages/locales/src/locales/de-DE/receive.json
index e71f8e7..a4c1540 100644
--- a/packages/locales/src/locales/de-DE/receive.json
+++ b/packages/locales/src/locales/de-DE/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Webcam verwenden oder ein gespeichertes QR-Bild importieren",
"scanOrImportQrHintMobile": "Kamera verwenden oder ein gespeichertes Bild importieren",
"importImage": "Bild importieren",
- "importFromImage": "Aus Bild importieren"
+ "importFromImage": "Aus Bild importieren",
+ "resume": "Fortsetzen",
+ "stop": "Anhalten",
+ "resumeAll": "Alle fortsetzen"
},
"errors": {
"invalidCode": "Geben Sie einen gültigen 64-stelligen Hex-Code ein.",
@@ -114,6 +117,9 @@
"ready": "Bereit",
"saved": "Gespeichert",
"failed": "Fehlgeschlagen",
+ "paused": "Angehalten",
+ "resuming": "Wird fortgesetzt…",
+ "waiting": "Wartet…",
"downloadingPercent": "{{percent}} % wird heruntergeladen",
"percent": "{{percent}} %",
"waitingForFiles": "Warte auf Dateien vom Sender…"
diff --git a/packages/locales/src/locales/de-DE/send.json b/packages/locales/src/locales/de-DE/send.json
index 466687f..4f8936e 100644
--- a/packages/locales/src/locales/de-DE/send.json
+++ b/packages/locales/src/locales/de-DE/send.json
@@ -41,6 +41,7 @@
"uploading": "Hochladen…",
"waiting": "Warten",
"failed": "Fehlgeschlagen",
+ "paused": "Angehalten",
"downloaded": "Heruntergeladen",
"disconnected": "Nicht verbunden",
"online": "Verbunden",
diff --git a/packages/locales/src/locales/en-GB/receive.json b/packages/locales/src/locales/en-GB/receive.json
index be6ad5c..de86cc8 100644
--- a/packages/locales/src/locales/en-GB/receive.json
+++ b/packages/locales/src/locales/en-GB/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Use the webcam, or import a saved QR image",
"scanOrImportQrHintMobile": "Use the camera, or import a saved image",
"importImage": "Import image",
- "importFromImage": "Import from image"
+ "importFromImage": "Import from image",
+ "resume": "Resume",
+ "stop": "Stop",
+ "resumeAll": "Resume all"
},
"errors": {
"invalidCode": "Enter a valid 64-character hex code.",
@@ -114,6 +117,9 @@
"ready": "Ready",
"saved": "Saved",
"failed": "Failed",
+ "paused": "Paused",
+ "resuming": "Resuming…",
+ "waiting": "Waiting…",
"downloadingPercent": "Downloading {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "Waiting for files from sender…"
diff --git a/packages/locales/src/locales/en-GB/send.json b/packages/locales/src/locales/en-GB/send.json
index d9e66f3..8090d70 100644
--- a/packages/locales/src/locales/en-GB/send.json
+++ b/packages/locales/src/locales/en-GB/send.json
@@ -41,6 +41,7 @@
"uploading": "Uploading…",
"waiting": "Waiting",
"failed": "Failed",
+ "paused": "Paused",
"downloaded": "Downloaded",
"disconnected": "Disconnected",
"online": "Online",
diff --git a/packages/locales/src/locales/en-US/receive.json b/packages/locales/src/locales/en-US/receive.json
index e242d52..c091ef4 100644
--- a/packages/locales/src/locales/en-US/receive.json
+++ b/packages/locales/src/locales/en-US/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Use the webcam, or import a saved QR image",
"scanOrImportQrHintMobile": "Use the camera, or import a saved image",
"importImage": "Import image",
- "importFromImage": "Import from image"
+ "importFromImage": "Import from image",
+ "resume": "Resume",
+ "stop": "Stop",
+ "resumeAll": "Resume all"
},
"errors": {
"invalidCode": "Enter a valid 64-character hex code.",
@@ -114,6 +117,9 @@
"ready": "Ready",
"saved": "Saved",
"failed": "Failed",
+ "paused": "Paused",
+ "resuming": "Resuming…",
+ "waiting": "Waiting…",
"downloadingPercent": "Downloading {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "Waiting for files from sender…"
diff --git a/packages/locales/src/locales/en-US/send.json b/packages/locales/src/locales/en-US/send.json
index d9e66f3..8090d70 100644
--- a/packages/locales/src/locales/en-US/send.json
+++ b/packages/locales/src/locales/en-US/send.json
@@ -41,6 +41,7 @@
"uploading": "Uploading…",
"waiting": "Waiting",
"failed": "Failed",
+ "paused": "Paused",
"downloaded": "Downloaded",
"disconnected": "Disconnected",
"online": "Online",
diff --git a/packages/locales/src/locales/es-419/receive.json b/packages/locales/src/locales/es-419/receive.json
index 7f14f9b..d16ed08 100644
--- a/packages/locales/src/locales/es-419/receive.json
+++ b/packages/locales/src/locales/es-419/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Usa la cámara web o importa una imagen QR guardada",
"scanOrImportQrHintMobile": "Usa la cámara o importa una imagen guardada",
"importImage": "Importar imagen",
- "importFromImage": "Importar desde imagen"
+ "importFromImage": "Importar desde imagen",
+ "resume": "Reanudar",
+ "stop": "Detener",
+ "resumeAll": "Reanudar todo"
},
"errors": {
"invalidCode": "Ingrese un código hexadecimal válido de 64 caracteres.",
@@ -114,6 +117,9 @@
"ready": "Listo",
"saved": "Guardado",
"failed": "Fallido",
+ "paused": "En pausa",
+ "resuming": "Reanudando…",
+ "waiting": "En espera…",
"downloadingPercent": "Descargando {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "Esperando archivos del remitente…"
diff --git a/packages/locales/src/locales/es-419/send.json b/packages/locales/src/locales/es-419/send.json
index 46aaabe..daec2f3 100644
--- a/packages/locales/src/locales/es-419/send.json
+++ b/packages/locales/src/locales/es-419/send.json
@@ -41,6 +41,7 @@
"uploading": "Subiendo…",
"waiting": "esperando",
"failed": "Fallido",
+ "paused": "En pausa",
"downloaded": "Descargado",
"disconnected": "desconectado",
"online": "En línea",
diff --git a/packages/locales/src/locales/es-ES/receive.json b/packages/locales/src/locales/es-ES/receive.json
index 7f14f9b..d16ed08 100644
--- a/packages/locales/src/locales/es-ES/receive.json
+++ b/packages/locales/src/locales/es-ES/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Usa la cámara web o importa una imagen QR guardada",
"scanOrImportQrHintMobile": "Usa la cámara o importa una imagen guardada",
"importImage": "Importar imagen",
- "importFromImage": "Importar desde imagen"
+ "importFromImage": "Importar desde imagen",
+ "resume": "Reanudar",
+ "stop": "Detener",
+ "resumeAll": "Reanudar todo"
},
"errors": {
"invalidCode": "Ingrese un código hexadecimal válido de 64 caracteres.",
@@ -114,6 +117,9 @@
"ready": "Listo",
"saved": "Guardado",
"failed": "Fallido",
+ "paused": "En pausa",
+ "resuming": "Reanudando…",
+ "waiting": "En espera…",
"downloadingPercent": "Descargando {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "Esperando archivos del remitente…"
diff --git a/packages/locales/src/locales/es-ES/send.json b/packages/locales/src/locales/es-ES/send.json
index 55037c8..7670ddd 100644
--- a/packages/locales/src/locales/es-ES/send.json
+++ b/packages/locales/src/locales/es-ES/send.json
@@ -41,6 +41,7 @@
"uploading": "Subiendo…",
"waiting": "esperando",
"failed": "Fallido",
+ "paused": "En pausa",
"downloaded": "Descargado",
"disconnected": "desconectado",
"online": "En línea",
diff --git a/packages/locales/src/locales/fr-FR/receive.json b/packages/locales/src/locales/fr-FR/receive.json
index 9686fb2..6784f93 100644
--- a/packages/locales/src/locales/fr-FR/receive.json
+++ b/packages/locales/src/locales/fr-FR/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Utilisez la webcam ou importez une image QR enregistrée",
"scanOrImportQrHintMobile": "Utilisez l’appareil photo ou importez une image enregistrée",
"importImage": "Importer une image",
- "importFromImage": "Importer depuis une image"
+ "importFromImage": "Importer depuis une image",
+ "resume": "Reprendre",
+ "stop": "Arrêter",
+ "resumeAll": "Tout reprendre"
},
"errors": {
"invalidCode": "Entrez un code hexadécimal valide de 64 caractères.",
@@ -114,6 +117,9 @@
"ready": "Prêt",
"saved": "Enregistré",
"failed": "Échec",
+ "paused": "En pause",
+ "resuming": "Reprise…",
+ "waiting": "En attente…",
"downloadingPercent": "Téléchargement de {{percent}} %",
"percent": "{{percent}} %",
"waitingForFiles": "En attente des fichiers de l'expéditeur…"
diff --git a/packages/locales/src/locales/fr-FR/send.json b/packages/locales/src/locales/fr-FR/send.json
index c255847..ec0cf94 100644
--- a/packages/locales/src/locales/fr-FR/send.json
+++ b/packages/locales/src/locales/fr-FR/send.json
@@ -41,6 +41,7 @@
"uploading": "Téléchargement…",
"waiting": "En attente",
"failed": "Échec",
+ "paused": "En pause",
"downloaded": "Téléchargé",
"disconnected": "Déconnecté",
"online": "En ligne",
diff --git a/packages/locales/src/locales/it-IT/receive.json b/packages/locales/src/locales/it-IT/receive.json
index d290a0f..1f555d1 100644
--- a/packages/locales/src/locales/it-IT/receive.json
+++ b/packages/locales/src/locales/it-IT/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Usa la webcam o importa un’immagine QR salvata",
"scanOrImportQrHintMobile": "Usa la fotocamera o importa un’immagine salvata",
"importImage": "Importa immagine",
- "importFromImage": "Importa da immagine"
+ "importFromImage": "Importa da immagine",
+ "resume": "Riprendi",
+ "stop": "Ferma",
+ "resumeAll": "Riprendi tutto"
},
"errors": {
"invalidCode": "Inserisci un codice esadecimale valido di 64 caratteri.",
@@ -114,6 +117,9 @@
"ready": "Pronto",
"saved": "Salvato",
"failed": "Fallito",
+ "paused": "In pausa",
+ "resuming": "Ripresa…",
+ "waiting": "In attesa…",
"downloadingPercent": "Download di {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "In attesa dei file dal mittente…"
diff --git a/packages/locales/src/locales/it-IT/send.json b/packages/locales/src/locales/it-IT/send.json
index d549b4c..fd7dba3 100644
--- a/packages/locales/src/locales/it-IT/send.json
+++ b/packages/locales/src/locales/it-IT/send.json
@@ -41,6 +41,7 @@
"uploading": "Caricamento…",
"waiting": "In attesa",
"failed": "Fallito",
+ "paused": "In pausa",
"downloaded": "Scaricato",
"disconnected": "Disconnesso",
"online": "In linea",
diff --git a/packages/locales/src/locales/ja-JP/receive.json b/packages/locales/src/locales/ja-JP/receive.json
index 9bf32db..221a84e 100644
--- a/packages/locales/src/locales/ja-JP/receive.json
+++ b/packages/locales/src/locales/ja-JP/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Webカメラを使うか、保存済みのQR画像を読み込みます",
"scanOrImportQrHintMobile": "カメラを使うか、保存済み画像を読み込みます",
"importImage": "画像を読み込む",
- "importFromImage": "画像から読み込む"
+ "importFromImage": "画像から読み込む",
+ "resume": "再開",
+ "stop": "停止",
+ "resumeAll": "すべて再開"
},
"errors": {
"invalidCode": "有効な64文字の16進コードを入力してください。",
@@ -114,6 +117,9 @@
"ready": "準備完了",
"saved": "保存済み",
"failed": "失敗",
+ "paused": "一時停止中",
+ "resuming": "再開中…",
+ "waiting": "待機中…",
"downloadingPercent": "{{percent}}% ダウンロード中",
"percent": "{{percent}}%",
"waitingForFiles": "送信者からのファイルを待機中…"
diff --git a/packages/locales/src/locales/ja-JP/send.json b/packages/locales/src/locales/ja-JP/send.json
index 48ea5e6..1f6699f 100644
--- a/packages/locales/src/locales/ja-JP/send.json
+++ b/packages/locales/src/locales/ja-JP/send.json
@@ -41,6 +41,7 @@
"uploading": "アップロード中…",
"waiting": "待機中",
"failed": "失敗",
+ "paused": "一時停止中",
"downloaded": "ダウンロード済み",
"disconnected": "切断",
"online": "オンライン",
diff --git a/packages/locales/src/locales/ko-KR/receive.json b/packages/locales/src/locales/ko-KR/receive.json
index b6cfc93..532bb34 100644
--- a/packages/locales/src/locales/ko-KR/receive.json
+++ b/packages/locales/src/locales/ko-KR/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "웹캠을 사용하거나 저장된 QR 이미지를 가져옵니다",
"scanOrImportQrHintMobile": "카메라를 사용하거나 저장된 이미지를 가져옵니다",
"importImage": "이미지 가져오기",
- "importFromImage": "이미지에서 가져오기"
+ "importFromImage": "이미지에서 가져오기",
+ "resume": "이어받기",
+ "stop": "중지",
+ "resumeAll": "모두 이어받기"
},
"errors": {
"invalidCode": "유효한 64자의 16진수 코드를 입력하세요.",
@@ -114,6 +117,9 @@
"ready": "준비",
"saved": "저장됨",
"failed": "실패",
+ "paused": "일시중지됨",
+ "resuming": "이어받는 중…",
+ "waiting": "대기 중…",
"downloadingPercent": "{{percent}}% 다운로드 중",
"percent": "{{percent}}%",
"waitingForFiles": "보내는 사람의 파일을 기다리는 중…"
diff --git a/packages/locales/src/locales/ko-KR/send.json b/packages/locales/src/locales/ko-KR/send.json
index c0be460..0983b6b 100644
--- a/packages/locales/src/locales/ko-KR/send.json
+++ b/packages/locales/src/locales/ko-KR/send.json
@@ -41,6 +41,7 @@
"uploading": "업로드 중…",
"waiting": "대기 중",
"failed": "실패",
+ "paused": "일시중지됨",
"downloaded": "다운로드됨",
"disconnected": "연결이 끊김",
"online": "온라인",
diff --git a/packages/locales/src/locales/pt-BR/receive.json b/packages/locales/src/locales/pt-BR/receive.json
index 2c1db1a..13ee5cf 100644
--- a/packages/locales/src/locales/pt-BR/receive.json
+++ b/packages/locales/src/locales/pt-BR/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Use a webcam ou importe uma imagem QR salva",
"scanOrImportQrHintMobile": "Use a câmera ou importe uma imagem salva",
"importImage": "Importar imagem",
- "importFromImage": "Importar de imagem"
+ "importFromImage": "Importar de imagem",
+ "resume": "Retomar",
+ "stop": "Parar",
+ "resumeAll": "Retomar tudo"
},
"errors": {
"invalidCode": "Insira um código hexadecimal válido de 64 caracteres.",
@@ -114,6 +117,9 @@
"ready": "Pronto",
"saved": "Salvo",
"failed": "Falha",
+ "paused": "Pausado",
+ "resuming": "Retomando…",
+ "waiting": "Aguardando…",
"downloadingPercent": "Baixando {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "Aguardando arquivos do remetente…"
diff --git a/packages/locales/src/locales/pt-BR/send.json b/packages/locales/src/locales/pt-BR/send.json
index bc1e0d3..389e4e6 100644
--- a/packages/locales/src/locales/pt-BR/send.json
+++ b/packages/locales/src/locales/pt-BR/send.json
@@ -41,6 +41,7 @@
"uploading": "Enviando…",
"waiting": "Aguardando",
"failed": "Falha",
+ "paused": "Pausado",
"downloaded": "Baixado",
"disconnected": "Desconectado",
"online": "On-line",
diff --git a/packages/locales/src/locales/ru-RU/receive.json b/packages/locales/src/locales/ru-RU/receive.json
index b36513d..bb66cf1 100644
--- a/packages/locales/src/locales/ru-RU/receive.json
+++ b/packages/locales/src/locales/ru-RU/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "Используйте веб-камеру или импортируйте сохранённое QR-изображение",
"scanOrImportQrHintMobile": "Используйте камеру или импортируйте сохранённое изображение",
"importImage": "Импортировать изображение",
- "importFromImage": "Импортировать из изображения"
+ "importFromImage": "Импортировать из изображения",
+ "resume": "Возобновить",
+ "stop": "Остановить",
+ "resumeAll": "Возобновить все"
},
"errors": {
"invalidCode": "Введите корректный 64-символьный шестнадцатеричный код.",
@@ -114,6 +117,9 @@
"ready": "Готово",
"saved": "Сохранено",
"failed": "Ошибка",
+ "paused": "Приостановлено",
+ "resuming": "Возобновление…",
+ "waiting": "Ожидание…",
"downloadingPercent": "Загрузка {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "Ожидание файлов от отправителя…"
diff --git a/packages/locales/src/locales/ru-RU/send.json b/packages/locales/src/locales/ru-RU/send.json
index d97e186..e99a534 100644
--- a/packages/locales/src/locales/ru-RU/send.json
+++ b/packages/locales/src/locales/ru-RU/send.json
@@ -41,6 +41,7 @@
"uploading": "Загрузка…",
"waiting": "Ожидание",
"failed": "Ошибка",
+ "paused": "Приостановлено",
"downloaded": "Скачано",
"disconnected": "Отключено",
"online": "В сети",
diff --git a/packages/locales/src/locales/zh-CN/receive.json b/packages/locales/src/locales/zh-CN/receive.json
index 19bbdf5..62ef18c 100644
--- a/packages/locales/src/locales/zh-CN/receive.json
+++ b/packages/locales/src/locales/zh-CN/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "使用摄像头,或导入已保存的二维码图片",
"scanOrImportQrHintMobile": "使用相机,或导入已保存的图片",
"importImage": "导入图片",
- "importFromImage": "从图片导入"
+ "importFromImage": "从图片导入",
+ "resume": "继续",
+ "stop": "停止",
+ "resumeAll": "全部继续"
},
"errors": {
"invalidCode": "输入有效的 64 字符十六进制代码。",
@@ -114,6 +117,9 @@
"ready": "准备好了",
"saved": "已保存",
"failed": "失败",
+ "paused": "已暂停",
+ "resuming": "正在继续…",
+ "waiting": "等待中…",
"downloadingPercent": "正在下载 {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "正在等待发送者的文件…"
diff --git a/packages/locales/src/locales/zh-CN/send.json b/packages/locales/src/locales/zh-CN/send.json
index 1b57ec7..68ea9cb 100644
--- a/packages/locales/src/locales/zh-CN/send.json
+++ b/packages/locales/src/locales/zh-CN/send.json
@@ -41,6 +41,7 @@
"uploading": "正在上传...",
"waiting": "等待",
"failed": "失败",
+ "paused": "已暂停",
"downloaded": "已下载",
"disconnected": "已断开连接",
"online": "在线",
diff --git a/packages/locales/src/locales/zh-TW/receive.json b/packages/locales/src/locales/zh-TW/receive.json
index 4104180..29c4d11 100644
--- a/packages/locales/src/locales/zh-TW/receive.json
+++ b/packages/locales/src/locales/zh-TW/receive.json
@@ -66,7 +66,10 @@
"scanOrImportQrHintDesktop": "使用網路攝影機,或匯入已儲存的 QR 圖片",
"scanOrImportQrHintMobile": "使用相機,或匯入已儲存的圖片",
"importImage": "匯入圖片",
- "importFromImage": "從圖片匯入"
+ "importFromImage": "從圖片匯入",
+ "resume": "繼續",
+ "stop": "停止",
+ "resumeAll": "全部繼續"
},
"errors": {
"invalidCode": "輸入有效的 64 字元十六進位代碼。",
@@ -114,6 +117,9 @@
"ready": "準備好了",
"saved": "已儲存",
"failed": "失敗",
+ "paused": "已暫停",
+ "resuming": "正在繼續…",
+ "waiting": "等待中…",
"downloadingPercent": "正在下載 {{percent}}%",
"percent": "{{percent}}%",
"waitingForFiles": "正在等待傳送者的檔案…"
diff --git a/packages/locales/src/locales/zh-TW/send.json b/packages/locales/src/locales/zh-TW/send.json
index 38fcaac..188a954 100644
--- a/packages/locales/src/locales/zh-TW/send.json
+++ b/packages/locales/src/locales/zh-TW/send.json
@@ -41,6 +41,7 @@
"uploading": "正在上傳...",
"waiting": "等待",
"failed": "失敗",
+ "paused": "已暫停",
"downloaded": "已下載",
"disconnected": "已斷開連接",
"online": "網路",