chadtmiller.com / pds.js
A minimal AT Protocol Personal Data Server written in JavaScript.
atproto pds
41
fork

Configure Feed

Select the types of activity you want to include in your feed.

migrate to vitest

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Chad Miller 0689d209 d8401977

+1649 -561
+1
.gitignore
··· 4 4 .env 5 5 .dev.vars 6 6 .backup/ 7 + coverage/
+1211 -2
package-lock.json
··· 1 1 { 2 2 "name": "pds.js", 3 - "version": "0.1.0", 3 + "version": "0.6.0", 4 4 "lockfileVersion": 3, 5 5 "requires": true, 6 6 "packages": { 7 7 "": { 8 8 "name": "pds.js", 9 - "version": "0.1.0", 9 + "version": "0.6.0", 10 10 "devDependencies": { 11 11 "@biomejs/biome": "^2.3.11", 12 12 "@cloudflare/workers-types": "^4.20260103.0", 13 + "@vitest/coverage-v8": "^4.0.16", 13 14 "typescript": "^5.9.3", 15 + "vitest": "^4.0.16", 14 16 "wrangler": "^4.54.0" 17 + } 18 + }, 19 + "node_modules/@babel/helper-string-parser": { 20 + "version": "7.27.1", 21 + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", 22 + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", 23 + "dev": true, 24 + "license": "MIT", 25 + "engines": { 26 + "node": ">=6.9.0" 27 + } 28 + }, 29 + "node_modules/@babel/helper-validator-identifier": { 30 + "version": "7.28.5", 31 + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", 32 + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", 33 + "dev": true, 34 + "license": "MIT", 35 + "engines": { 36 + "node": ">=6.9.0" 37 + } 38 + }, 39 + "node_modules/@babel/parser": { 40 + "version": "7.28.5", 41 + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz", 42 + "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==", 43 + "dev": true, 44 + "license": "MIT", 45 + "dependencies": { 46 + "@babel/types": "^7.28.5" 47 + }, 48 + "bin": { 49 + "parser": "bin/babel-parser.js" 50 + }, 51 + "engines": { 52 + "node": ">=6.0.0" 53 + } 54 + }, 55 + "node_modules/@babel/types": { 56 + "version": "7.28.5", 57 + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz", 58 + "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==", 59 + "dev": true, 60 + "license": "MIT", 61 + "dependencies": { 62 + "@babel/helper-string-parser": "^7.27.1", 63 + "@babel/helper-validator-identifier": "^7.28.5" 64 + }, 65 + "engines": { 66 + "node": ">=6.9.0" 67 + } 68 + }, 69 + "node_modules/@bcoe/v8-coverage": { 70 + "version": "1.0.2", 71 + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz", 72 + "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==", 73 + "dev": true, 74 + "license": "MIT", 75 + "engines": { 76 + "node": ">=18" 15 77 } 16 78 }, 17 79 "node_modules/@biomejs/biome": { ··· 1201 1263 "dev": true, 1202 1264 "license": "MIT" 1203 1265 }, 1266 + "node_modules/@rollup/rollup-android-arm-eabi": { 1267 + "version": "4.55.1", 1268 + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.55.1.tgz", 1269 + "integrity": "sha512-9R0DM/ykwfGIlNu6+2U09ga0WXeZ9MRC2Ter8jnz8415VbuIykVuc6bhdrbORFZANDmTDvq26mJrEVTl8TdnDg==", 1270 + "cpu": [ 1271 + "arm" 1272 + ], 1273 + "dev": true, 1274 + "license": "MIT", 1275 + "optional": true, 1276 + "os": [ 1277 + "android" 1278 + ] 1279 + }, 1280 + "node_modules/@rollup/rollup-android-arm64": { 1281 + "version": "4.55.1", 1282 + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.55.1.tgz", 1283 + "integrity": "sha512-eFZCb1YUqhTysgW3sj/55du5cG57S7UTNtdMjCW7LwVcj3dTTcowCsC8p7uBdzKsZYa8J7IDE8lhMI+HX1vQvg==", 1284 + "cpu": [ 1285 + "arm64" 1286 + ], 1287 + "dev": true, 1288 + "license": "MIT", 1289 + "optional": true, 1290 + "os": [ 1291 + "android" 1292 + ] 1293 + }, 1294 + "node_modules/@rollup/rollup-darwin-arm64": { 1295 + "version": "4.55.1", 1296 + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.55.1.tgz", 1297 + "integrity": "sha512-p3grE2PHcQm2e8PSGZdzIhCKbMCw/xi9XvMPErPhwO17vxtvCN5FEA2mSLgmKlCjHGMQTP6phuQTYWUnKewwGg==", 1298 + "cpu": [ 1299 + "arm64" 1300 + ], 1301 + "dev": true, 1302 + "license": "MIT", 1303 + "optional": true, 1304 + "os": [ 1305 + "darwin" 1306 + ] 1307 + }, 1308 + "node_modules/@rollup/rollup-darwin-x64": { 1309 + "version": "4.55.1", 1310 + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.55.1.tgz", 1311 + "integrity": "sha512-rDUjG25C9qoTm+e02Esi+aqTKSBYwVTaoS1wxcN47/Luqef57Vgp96xNANwt5npq9GDxsH7kXxNkJVEsWEOEaQ==", 1312 + "cpu": [ 1313 + "x64" 1314 + ], 1315 + "dev": true, 1316 + "license": "MIT", 1317 + "optional": true, 1318 + "os": [ 1319 + "darwin" 1320 + ] 1321 + }, 1322 + "node_modules/@rollup/rollup-freebsd-arm64": { 1323 + "version": "4.55.1", 1324 + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.55.1.tgz", 1325 + "integrity": "sha512-+JiU7Jbp5cdxekIgdte0jfcu5oqw4GCKr6i3PJTlXTCU5H5Fvtkpbs4XJHRmWNXF+hKmn4v7ogI5OQPaupJgOg==", 1326 + "cpu": [ 1327 + "arm64" 1328 + ], 1329 + "dev": true, 1330 + "license": "MIT", 1331 + "optional": true, 1332 + "os": [ 1333 + "freebsd" 1334 + ] 1335 + }, 1336 + "node_modules/@rollup/rollup-freebsd-x64": { 1337 + "version": "4.55.1", 1338 + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.55.1.tgz", 1339 + "integrity": "sha512-V5xC1tOVWtLLmr3YUk2f6EJK4qksksOYiz/TCsFHu/R+woubcLWdC9nZQmwjOAbmExBIVKsm1/wKmEy4z4u4Bw==", 1340 + "cpu": [ 1341 + "x64" 1342 + ], 1343 + "dev": true, 1344 + "license": "MIT", 1345 + "optional": true, 1346 + "os": [ 1347 + "freebsd" 1348 + ] 1349 + }, 1350 + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { 1351 + "version": "4.55.1", 1352 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.55.1.tgz", 1353 + "integrity": "sha512-Rn3n+FUk2J5VWx+ywrG/HGPTD9jXNbicRtTM11e/uorplArnXZYsVifnPPqNNP5BsO3roI4n8332ukpY/zN7rQ==", 1354 + "cpu": [ 1355 + "arm" 1356 + ], 1357 + "dev": true, 1358 + "license": "MIT", 1359 + "optional": true, 1360 + "os": [ 1361 + "linux" 1362 + ] 1363 + }, 1364 + "node_modules/@rollup/rollup-linux-arm-musleabihf": { 1365 + "version": "4.55.1", 1366 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.55.1.tgz", 1367 + "integrity": "sha512-grPNWydeKtc1aEdrJDWk4opD7nFtQbMmV7769hiAaYyUKCT1faPRm2av8CX1YJsZ4TLAZcg9gTR1KvEzoLjXkg==", 1368 + "cpu": [ 1369 + "arm" 1370 + ], 1371 + "dev": true, 1372 + "license": "MIT", 1373 + "optional": true, 1374 + "os": [ 1375 + "linux" 1376 + ] 1377 + }, 1378 + "node_modules/@rollup/rollup-linux-arm64-gnu": { 1379 + "version": "4.55.1", 1380 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.55.1.tgz", 1381 + "integrity": "sha512-a59mwd1k6x8tXKcUxSyISiquLwB5pX+fJW9TkWU46lCqD/GRDe9uDN31jrMmVP3feI3mhAdvcCClhV8V5MhJFQ==", 1382 + "cpu": [ 1383 + "arm64" 1384 + ], 1385 + "dev": true, 1386 + "license": "MIT", 1387 + "optional": true, 1388 + "os": [ 1389 + "linux" 1390 + ] 1391 + }, 1392 + "node_modules/@rollup/rollup-linux-arm64-musl": { 1393 + "version": "4.55.1", 1394 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.55.1.tgz", 1395 + "integrity": "sha512-puS1MEgWX5GsHSoiAsF0TYrpomdvkaXm0CofIMG5uVkP6IBV+ZO9xhC5YEN49nsgYo1DuuMquF9+7EDBVYu4uA==", 1396 + "cpu": [ 1397 + "arm64" 1398 + ], 1399 + "dev": true, 1400 + "license": "MIT", 1401 + "optional": true, 1402 + "os": [ 1403 + "linux" 1404 + ] 1405 + }, 1406 + "node_modules/@rollup/rollup-linux-loong64-gnu": { 1407 + "version": "4.55.1", 1408 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.55.1.tgz", 1409 + "integrity": "sha512-r3Wv40in+lTsULSb6nnoudVbARdOwb2u5fpeoOAZjFLznp6tDU8kd+GTHmJoqZ9lt6/Sys33KdIHUaQihFcu7g==", 1410 + "cpu": [ 1411 + "loong64" 1412 + ], 1413 + "dev": true, 1414 + "license": "MIT", 1415 + "optional": true, 1416 + "os": [ 1417 + "linux" 1418 + ] 1419 + }, 1420 + "node_modules/@rollup/rollup-linux-loong64-musl": { 1421 + "version": "4.55.1", 1422 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.55.1.tgz", 1423 + "integrity": "sha512-MR8c0+UxAlB22Fq4R+aQSPBayvYa3+9DrwG/i1TKQXFYEaoW3B5b/rkSRIypcZDdWjWnpcvxbNaAJDcSbJU3Lw==", 1424 + "cpu": [ 1425 + "loong64" 1426 + ], 1427 + "dev": true, 1428 + "license": "MIT", 1429 + "optional": true, 1430 + "os": [ 1431 + "linux" 1432 + ] 1433 + }, 1434 + "node_modules/@rollup/rollup-linux-ppc64-gnu": { 1435 + "version": "4.55.1", 1436 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.55.1.tgz", 1437 + "integrity": "sha512-3KhoECe1BRlSYpMTeVrD4sh2Pw2xgt4jzNSZIIPLFEsnQn9gAnZagW9+VqDqAHgm1Xc77LzJOo2LdigS5qZ+gw==", 1438 + "cpu": [ 1439 + "ppc64" 1440 + ], 1441 + "dev": true, 1442 + "license": "MIT", 1443 + "optional": true, 1444 + "os": [ 1445 + "linux" 1446 + ] 1447 + }, 1448 + "node_modules/@rollup/rollup-linux-ppc64-musl": { 1449 + "version": "4.55.1", 1450 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.55.1.tgz", 1451 + "integrity": "sha512-ziR1OuZx0vdYZZ30vueNZTg73alF59DicYrPViG0NEgDVN8/Jl87zkAPu4u6VjZST2llgEUjaiNl9JM6HH1Vdw==", 1452 + "cpu": [ 1453 + "ppc64" 1454 + ], 1455 + "dev": true, 1456 + "license": "MIT", 1457 + "optional": true, 1458 + "os": [ 1459 + "linux" 1460 + ] 1461 + }, 1462 + "node_modules/@rollup/rollup-linux-riscv64-gnu": { 1463 + "version": "4.55.1", 1464 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.55.1.tgz", 1465 + "integrity": "sha512-uW0Y12ih2XJRERZ4jAfKamTyIHVMPQnTZcQjme2HMVDAHY4amf5u414OqNYC+x+LzRdRcnIG1YodLrrtA8xsxw==", 1466 + "cpu": [ 1467 + "riscv64" 1468 + ], 1469 + "dev": true, 1470 + "license": "MIT", 1471 + "optional": true, 1472 + "os": [ 1473 + "linux" 1474 + ] 1475 + }, 1476 + "node_modules/@rollup/rollup-linux-riscv64-musl": { 1477 + "version": "4.55.1", 1478 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.55.1.tgz", 1479 + "integrity": "sha512-u9yZ0jUkOED1BFrqu3BwMQoixvGHGZ+JhJNkNKY/hyoEgOwlqKb62qu+7UjbPSHYjiVy8kKJHvXKv5coH4wDeg==", 1480 + "cpu": [ 1481 + "riscv64" 1482 + ], 1483 + "dev": true, 1484 + "license": "MIT", 1485 + "optional": true, 1486 + "os": [ 1487 + "linux" 1488 + ] 1489 + }, 1490 + "node_modules/@rollup/rollup-linux-s390x-gnu": { 1491 + "version": "4.55.1", 1492 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.55.1.tgz", 1493 + "integrity": "sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==", 1494 + "cpu": [ 1495 + "s390x" 1496 + ], 1497 + "dev": true, 1498 + "license": "MIT", 1499 + "optional": true, 1500 + "os": [ 1501 + "linux" 1502 + ] 1503 + }, 1504 + "node_modules/@rollup/rollup-linux-x64-gnu": { 1505 + "version": "4.55.1", 1506 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.55.1.tgz", 1507 + "integrity": "sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==", 1508 + "cpu": [ 1509 + "x64" 1510 + ], 1511 + "dev": true, 1512 + "license": "MIT", 1513 + "optional": true, 1514 + "os": [ 1515 + "linux" 1516 + ] 1517 + }, 1518 + "node_modules/@rollup/rollup-linux-x64-musl": { 1519 + "version": "4.55.1", 1520 + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.55.1.tgz", 1521 + "integrity": "sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==", 1522 + "cpu": [ 1523 + "x64" 1524 + ], 1525 + "dev": true, 1526 + "license": "MIT", 1527 + "optional": true, 1528 + "os": [ 1529 + "linux" 1530 + ] 1531 + }, 1532 + "node_modules/@rollup/rollup-openbsd-x64": { 1533 + "version": "4.55.1", 1534 + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.55.1.tgz", 1535 + "integrity": "sha512-eLXw0dOiqE4QmvikfQ6yjgkg/xDM+MdU9YJuP4ySTibXU0oAvnEWXt7UDJmD4UkYialMfOGFPJnIHSe/kdzPxg==", 1536 + "cpu": [ 1537 + "x64" 1538 + ], 1539 + "dev": true, 1540 + "license": "MIT", 1541 + "optional": true, 1542 + "os": [ 1543 + "openbsd" 1544 + ] 1545 + }, 1546 + "node_modules/@rollup/rollup-openharmony-arm64": { 1547 + "version": "4.55.1", 1548 + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.55.1.tgz", 1549 + "integrity": "sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==", 1550 + "cpu": [ 1551 + "arm64" 1552 + ], 1553 + "dev": true, 1554 + "license": "MIT", 1555 + "optional": true, 1556 + "os": [ 1557 + "openharmony" 1558 + ] 1559 + }, 1560 + "node_modules/@rollup/rollup-win32-arm64-msvc": { 1561 + "version": "4.55.1", 1562 + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.55.1.tgz", 1563 + "integrity": "sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==", 1564 + "cpu": [ 1565 + "arm64" 1566 + ], 1567 + "dev": true, 1568 + "license": "MIT", 1569 + "optional": true, 1570 + "os": [ 1571 + "win32" 1572 + ] 1573 + }, 1574 + "node_modules/@rollup/rollup-win32-ia32-msvc": { 1575 + "version": "4.55.1", 1576 + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.55.1.tgz", 1577 + "integrity": "sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==", 1578 + "cpu": [ 1579 + "ia32" 1580 + ], 1581 + "dev": true, 1582 + "license": "MIT", 1583 + "optional": true, 1584 + "os": [ 1585 + "win32" 1586 + ] 1587 + }, 1588 + "node_modules/@rollup/rollup-win32-x64-gnu": { 1589 + "version": "4.55.1", 1590 + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.55.1.tgz", 1591 + "integrity": "sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==", 1592 + "cpu": [ 1593 + "x64" 1594 + ], 1595 + "dev": true, 1596 + "license": "MIT", 1597 + "optional": true, 1598 + "os": [ 1599 + "win32" 1600 + ] 1601 + }, 1602 + "node_modules/@rollup/rollup-win32-x64-msvc": { 1603 + "version": "4.55.1", 1604 + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.55.1.tgz", 1605 + "integrity": "sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==", 1606 + "cpu": [ 1607 + "x64" 1608 + ], 1609 + "dev": true, 1610 + "license": "MIT", 1611 + "optional": true, 1612 + "os": [ 1613 + "win32" 1614 + ] 1615 + }, 1204 1616 "node_modules/@sindresorhus/is": { 1205 1617 "version": "7.2.0", 1206 1618 "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-7.2.0.tgz", ··· 1221 1633 "dev": true, 1222 1634 "license": "CC0-1.0" 1223 1635 }, 1636 + "node_modules/@standard-schema/spec": { 1637 + "version": "1.1.0", 1638 + "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", 1639 + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", 1640 + "dev": true, 1641 + "license": "MIT" 1642 + }, 1643 + "node_modules/@types/chai": { 1644 + "version": "5.2.3", 1645 + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", 1646 + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", 1647 + "dev": true, 1648 + "license": "MIT", 1649 + "dependencies": { 1650 + "@types/deep-eql": "*", 1651 + "assertion-error": "^2.0.1" 1652 + } 1653 + }, 1654 + "node_modules/@types/deep-eql": { 1655 + "version": "4.0.2", 1656 + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", 1657 + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", 1658 + "dev": true, 1659 + "license": "MIT" 1660 + }, 1661 + "node_modules/@types/estree": { 1662 + "version": "1.0.8", 1663 + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", 1664 + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", 1665 + "dev": true, 1666 + "license": "MIT" 1667 + }, 1668 + "node_modules/@vitest/coverage-v8": { 1669 + "version": "4.0.16", 1670 + "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.0.16.tgz", 1671 + "integrity": "sha512-2rNdjEIsPRzsdu6/9Eq0AYAzYdpP6Bx9cje9tL3FE5XzXRQF1fNU9pe/1yE8fCrS0HD+fBtt6gLPh6LI57tX7A==", 1672 + "dev": true, 1673 + "license": "MIT", 1674 + "dependencies": { 1675 + "@bcoe/v8-coverage": "^1.0.2", 1676 + "@vitest/utils": "4.0.16", 1677 + "ast-v8-to-istanbul": "^0.3.8", 1678 + "istanbul-lib-coverage": "^3.2.2", 1679 + "istanbul-lib-report": "^3.0.1", 1680 + "istanbul-lib-source-maps": "^5.0.6", 1681 + "istanbul-reports": "^3.2.0", 1682 + "magicast": "^0.5.1", 1683 + "obug": "^2.1.1", 1684 + "std-env": "^3.10.0", 1685 + "tinyrainbow": "^3.0.3" 1686 + }, 1687 + "funding": { 1688 + "url": "https://opencollective.com/vitest" 1689 + }, 1690 + "peerDependencies": { 1691 + "@vitest/browser": "4.0.16", 1692 + "vitest": "4.0.16" 1693 + }, 1694 + "peerDependenciesMeta": { 1695 + "@vitest/browser": { 1696 + "optional": true 1697 + } 1698 + } 1699 + }, 1700 + "node_modules/@vitest/expect": { 1701 + "version": "4.0.16", 1702 + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.16.tgz", 1703 + "integrity": "sha512-eshqULT2It7McaJkQGLkPjPjNph+uevROGuIMJdG3V+0BSR2w9u6J9Lwu+E8cK5TETlfou8GRijhafIMhXsimA==", 1704 + "dev": true, 1705 + "license": "MIT", 1706 + "dependencies": { 1707 + "@standard-schema/spec": "^1.0.0", 1708 + "@types/chai": "^5.2.2", 1709 + "@vitest/spy": "4.0.16", 1710 + "@vitest/utils": "4.0.16", 1711 + "chai": "^6.2.1", 1712 + "tinyrainbow": "^3.0.3" 1713 + }, 1714 + "funding": { 1715 + "url": "https://opencollective.com/vitest" 1716 + } 1717 + }, 1718 + "node_modules/@vitest/mocker": { 1719 + "version": "4.0.16", 1720 + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.16.tgz", 1721 + "integrity": "sha512-yb6k4AZxJTB+q9ycAvsoxGn+j/po0UaPgajllBgt1PzoMAAmJGYFdDk0uCcRcxb3BrME34I6u8gHZTQlkqSZpg==", 1722 + "dev": true, 1723 + "license": "MIT", 1724 + "dependencies": { 1725 + "@vitest/spy": "4.0.16", 1726 + "estree-walker": "^3.0.3", 1727 + "magic-string": "^0.30.21" 1728 + }, 1729 + "funding": { 1730 + "url": "https://opencollective.com/vitest" 1731 + }, 1732 + "peerDependencies": { 1733 + "msw": "^2.4.9", 1734 + "vite": "^6.0.0 || ^7.0.0-0" 1735 + }, 1736 + "peerDependenciesMeta": { 1737 + "msw": { 1738 + "optional": true 1739 + }, 1740 + "vite": { 1741 + "optional": true 1742 + } 1743 + } 1744 + }, 1745 + "node_modules/@vitest/pretty-format": { 1746 + "version": "4.0.16", 1747 + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.16.tgz", 1748 + "integrity": "sha512-eNCYNsSty9xJKi/UdVD8Ou16alu7AYiS2fCPRs0b1OdhJiV89buAXQLpTbe+X8V9L6qrs9CqyvU7OaAopJYPsA==", 1749 + "dev": true, 1750 + "license": "MIT", 1751 + "dependencies": { 1752 + "tinyrainbow": "^3.0.3" 1753 + }, 1754 + "funding": { 1755 + "url": "https://opencollective.com/vitest" 1756 + } 1757 + }, 1758 + "node_modules/@vitest/runner": { 1759 + "version": "4.0.16", 1760 + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.16.tgz", 1761 + "integrity": "sha512-VWEDm5Wv9xEo80ctjORcTQRJ539EGPB3Pb9ApvVRAY1U/WkHXmmYISqU5E79uCwcW7xYUV38gwZD+RV755fu3Q==", 1762 + "dev": true, 1763 + "license": "MIT", 1764 + "dependencies": { 1765 + "@vitest/utils": "4.0.16", 1766 + "pathe": "^2.0.3" 1767 + }, 1768 + "funding": { 1769 + "url": "https://opencollective.com/vitest" 1770 + } 1771 + }, 1772 + "node_modules/@vitest/snapshot": { 1773 + "version": "4.0.16", 1774 + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.16.tgz", 1775 + "integrity": "sha512-sf6NcrYhYBsSYefxnry+DR8n3UV4xWZwWxYbCJUt2YdvtqzSPR7VfGrY0zsv090DAbjFZsi7ZaMi1KnSRyK1XA==", 1776 + "dev": true, 1777 + "license": "MIT", 1778 + "dependencies": { 1779 + "@vitest/pretty-format": "4.0.16", 1780 + "magic-string": "^0.30.21", 1781 + "pathe": "^2.0.3" 1782 + }, 1783 + "funding": { 1784 + "url": "https://opencollective.com/vitest" 1785 + } 1786 + }, 1787 + "node_modules/@vitest/spy": { 1788 + "version": "4.0.16", 1789 + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.16.tgz", 1790 + "integrity": "sha512-4jIOWjKP0ZUaEmJm00E0cOBLU+5WE0BpeNr3XN6TEF05ltro6NJqHWxXD0kA8/Zc8Nh23AT8WQxwNG+WeROupw==", 1791 + "dev": true, 1792 + "license": "MIT", 1793 + "funding": { 1794 + "url": "https://opencollective.com/vitest" 1795 + } 1796 + }, 1797 + "node_modules/@vitest/utils": { 1798 + "version": "4.0.16", 1799 + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.16.tgz", 1800 + "integrity": "sha512-h8z9yYhV3e1LEfaQ3zdypIrnAg/9hguReGZoS7Gl0aBG5xgA410zBqECqmaF/+RkTggRsfnzc1XaAHA6bmUufA==", 1801 + "dev": true, 1802 + "license": "MIT", 1803 + "dependencies": { 1804 + "@vitest/pretty-format": "4.0.16", 1805 + "tinyrainbow": "^3.0.3" 1806 + }, 1807 + "funding": { 1808 + "url": "https://opencollective.com/vitest" 1809 + } 1810 + }, 1224 1811 "node_modules/acorn": { 1225 1812 "version": "8.14.0", 1226 1813 "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz", ··· 1244 1831 "node": ">=0.4.0" 1245 1832 } 1246 1833 }, 1834 + "node_modules/assertion-error": { 1835 + "version": "2.0.1", 1836 + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", 1837 + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", 1838 + "dev": true, 1839 + "license": "MIT", 1840 + "engines": { 1841 + "node": ">=12" 1842 + } 1843 + }, 1844 + "node_modules/ast-v8-to-istanbul": { 1845 + "version": "0.3.10", 1846 + "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-0.3.10.tgz", 1847 + "integrity": "sha512-p4K7vMz2ZSk3wN8l5o3y2bJAoZXT3VuJI5OLTATY/01CYWumWvwkUw0SqDBnNq6IiTO3qDa1eSQDibAV8g7XOQ==", 1848 + "dev": true, 1849 + "license": "MIT", 1850 + "dependencies": { 1851 + "@jridgewell/trace-mapping": "^0.3.31", 1852 + "estree-walker": "^3.0.3", 1853 + "js-tokens": "^9.0.1" 1854 + } 1855 + }, 1856 + "node_modules/ast-v8-to-istanbul/node_modules/@jridgewell/trace-mapping": { 1857 + "version": "0.3.31", 1858 + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", 1859 + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", 1860 + "dev": true, 1861 + "license": "MIT", 1862 + "dependencies": { 1863 + "@jridgewell/resolve-uri": "^3.1.0", 1864 + "@jridgewell/sourcemap-codec": "^1.4.14" 1865 + } 1866 + }, 1247 1867 "node_modules/blake3-wasm": { 1248 1868 "version": "2.1.5", 1249 1869 "resolved": "https://registry.npmjs.org/blake3-wasm/-/blake3-wasm-2.1.5.tgz", 1250 1870 "integrity": "sha512-F1+K8EbfOZE49dtoPtmxUQrpXaBIl3ICvasLh+nJta0xkz+9kF/7uet9fLnwKqhDrmj6g+6K3Tw9yQPUg2ka5g==", 1251 1871 "dev": true, 1252 1872 "license": "MIT" 1873 + }, 1874 + "node_modules/chai": { 1875 + "version": "6.2.2", 1876 + "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz", 1877 + "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==", 1878 + "dev": true, 1879 + "license": "MIT", 1880 + "engines": { 1881 + "node": ">=18" 1882 + } 1253 1883 }, 1254 1884 "node_modules/color": { 1255 1885 "version": "4.2.3", ··· 1310 1940 "url": "https://opencollective.com/express" 1311 1941 } 1312 1942 }, 1943 + "node_modules/debug": { 1944 + "version": "4.4.3", 1945 + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", 1946 + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", 1947 + "dev": true, 1948 + "license": "MIT", 1949 + "dependencies": { 1950 + "ms": "^2.1.3" 1951 + }, 1952 + "engines": { 1953 + "node": ">=6.0" 1954 + }, 1955 + "peerDependenciesMeta": { 1956 + "supports-color": { 1957 + "optional": true 1958 + } 1959 + } 1960 + }, 1313 1961 "node_modules/detect-libc": { 1314 1962 "version": "2.1.2", 1315 1963 "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", ··· 1329 1977 "funding": { 1330 1978 "url": "https://github.com/sponsors/antfu" 1331 1979 } 1980 + }, 1981 + "node_modules/es-module-lexer": { 1982 + "version": "1.7.0", 1983 + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", 1984 + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", 1985 + "dev": true, 1986 + "license": "MIT" 1332 1987 }, 1333 1988 "node_modules/esbuild": { 1334 1989 "version": "0.27.0", ··· 1372 2027 "@esbuild/win32-x64": "0.27.0" 1373 2028 } 1374 2029 }, 2030 + "node_modules/estree-walker": { 2031 + "version": "3.0.3", 2032 + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", 2033 + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", 2034 + "dev": true, 2035 + "license": "MIT", 2036 + "dependencies": { 2037 + "@types/estree": "^1.0.0" 2038 + } 2039 + }, 1375 2040 "node_modules/exit-hook": { 1376 2041 "version": "2.2.1", 1377 2042 "resolved": "https://registry.npmjs.org/exit-hook/-/exit-hook-2.2.1.tgz", ··· 1385 2050 "url": "https://github.com/sponsors/sindresorhus" 1386 2051 } 1387 2052 }, 2053 + "node_modules/expect-type": { 2054 + "version": "1.3.0", 2055 + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", 2056 + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", 2057 + "dev": true, 2058 + "license": "Apache-2.0", 2059 + "engines": { 2060 + "node": ">=12.0.0" 2061 + } 2062 + }, 2063 + "node_modules/fdir": { 2064 + "version": "6.5.0", 2065 + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", 2066 + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", 2067 + "dev": true, 2068 + "license": "MIT", 2069 + "engines": { 2070 + "node": ">=12.0.0" 2071 + }, 2072 + "peerDependencies": { 2073 + "picomatch": "^3 || ^4" 2074 + }, 2075 + "peerDependenciesMeta": { 2076 + "picomatch": { 2077 + "optional": true 2078 + } 2079 + } 2080 + }, 1388 2081 "node_modules/fsevents": { 1389 2082 "version": "2.3.3", 1390 2083 "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", ··· 1407 2100 "dev": true, 1408 2101 "license": "BSD-2-Clause" 1409 2102 }, 2103 + "node_modules/has-flag": { 2104 + "version": "4.0.0", 2105 + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", 2106 + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", 2107 + "dev": true, 2108 + "license": "MIT", 2109 + "engines": { 2110 + "node": ">=8" 2111 + } 2112 + }, 2113 + "node_modules/html-escaper": { 2114 + "version": "2.0.2", 2115 + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", 2116 + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", 2117 + "dev": true, 2118 + "license": "MIT" 2119 + }, 1410 2120 "node_modules/is-arrayish": { 1411 2121 "version": "0.3.4", 1412 2122 "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.4.tgz", ··· 1414 2124 "dev": true, 1415 2125 "license": "MIT" 1416 2126 }, 2127 + "node_modules/istanbul-lib-coverage": { 2128 + "version": "3.2.2", 2129 + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", 2130 + "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", 2131 + "dev": true, 2132 + "license": "BSD-3-Clause", 2133 + "engines": { 2134 + "node": ">=8" 2135 + } 2136 + }, 2137 + "node_modules/istanbul-lib-report": { 2138 + "version": "3.0.1", 2139 + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", 2140 + "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", 2141 + "dev": true, 2142 + "license": "BSD-3-Clause", 2143 + "dependencies": { 2144 + "istanbul-lib-coverage": "^3.0.0", 2145 + "make-dir": "^4.0.0", 2146 + "supports-color": "^7.1.0" 2147 + }, 2148 + "engines": { 2149 + "node": ">=10" 2150 + } 2151 + }, 2152 + "node_modules/istanbul-lib-report/node_modules/supports-color": { 2153 + "version": "7.2.0", 2154 + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", 2155 + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", 2156 + "dev": true, 2157 + "license": "MIT", 2158 + "dependencies": { 2159 + "has-flag": "^4.0.0" 2160 + }, 2161 + "engines": { 2162 + "node": ">=8" 2163 + } 2164 + }, 2165 + "node_modules/istanbul-lib-source-maps": { 2166 + "version": "5.0.6", 2167 + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-5.0.6.tgz", 2168 + "integrity": "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==", 2169 + "dev": true, 2170 + "license": "BSD-3-Clause", 2171 + "dependencies": { 2172 + "@jridgewell/trace-mapping": "^0.3.23", 2173 + "debug": "^4.1.1", 2174 + "istanbul-lib-coverage": "^3.0.0" 2175 + }, 2176 + "engines": { 2177 + "node": ">=10" 2178 + } 2179 + }, 2180 + "node_modules/istanbul-lib-source-maps/node_modules/@jridgewell/trace-mapping": { 2181 + "version": "0.3.31", 2182 + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", 2183 + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", 2184 + "dev": true, 2185 + "license": "MIT", 2186 + "dependencies": { 2187 + "@jridgewell/resolve-uri": "^3.1.0", 2188 + "@jridgewell/sourcemap-codec": "^1.4.14" 2189 + } 2190 + }, 2191 + "node_modules/istanbul-reports": { 2192 + "version": "3.2.0", 2193 + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz", 2194 + "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==", 2195 + "dev": true, 2196 + "license": "BSD-3-Clause", 2197 + "dependencies": { 2198 + "html-escaper": "^2.0.0", 2199 + "istanbul-lib-report": "^3.0.0" 2200 + }, 2201 + "engines": { 2202 + "node": ">=8" 2203 + } 2204 + }, 2205 + "node_modules/js-tokens": { 2206 + "version": "9.0.1", 2207 + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz", 2208 + "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==", 2209 + "dev": true, 2210 + "license": "MIT" 2211 + }, 1417 2212 "node_modules/kleur": { 1418 2213 "version": "4.1.5", 1419 2214 "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", ··· 1424 2219 "node": ">=6" 1425 2220 } 1426 2221 }, 2222 + "node_modules/magic-string": { 2223 + "version": "0.30.21", 2224 + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", 2225 + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", 2226 + "dev": true, 2227 + "license": "MIT", 2228 + "dependencies": { 2229 + "@jridgewell/sourcemap-codec": "^1.5.5" 2230 + } 2231 + }, 2232 + "node_modules/magicast": { 2233 + "version": "0.5.1", 2234 + "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.1.tgz", 2235 + "integrity": "sha512-xrHS24IxaLrvuo613F719wvOIv9xPHFWQHuvGUBmPnCA/3MQxKI3b+r7n1jAoDHmsbC5bRhTZYR77invLAxVnw==", 2236 + "dev": true, 2237 + "license": "MIT", 2238 + "dependencies": { 2239 + "@babel/parser": "^7.28.5", 2240 + "@babel/types": "^7.28.5", 2241 + "source-map-js": "^1.2.1" 2242 + } 2243 + }, 2244 + "node_modules/make-dir": { 2245 + "version": "4.0.0", 2246 + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", 2247 + "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", 2248 + "dev": true, 2249 + "license": "MIT", 2250 + "dependencies": { 2251 + "semver": "^7.5.3" 2252 + }, 2253 + "engines": { 2254 + "node": ">=10" 2255 + }, 2256 + "funding": { 2257 + "url": "https://github.com/sponsors/sindresorhus" 2258 + } 2259 + }, 1427 2260 "node_modules/mime": { 1428 2261 "version": "3.0.0", 1429 2262 "resolved": "https://registry.npmjs.org/mime/-/mime-3.0.0.tgz", ··· 1464 2297 "node": ">=18.0.0" 1465 2298 } 1466 2299 }, 2300 + "node_modules/ms": { 2301 + "version": "2.1.3", 2302 + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", 2303 + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", 2304 + "dev": true, 2305 + "license": "MIT" 2306 + }, 2307 + "node_modules/nanoid": { 2308 + "version": "3.3.11", 2309 + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", 2310 + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", 2311 + "dev": true, 2312 + "funding": [ 2313 + { 2314 + "type": "github", 2315 + "url": "https://github.com/sponsors/ai" 2316 + } 2317 + ], 2318 + "license": "MIT", 2319 + "bin": { 2320 + "nanoid": "bin/nanoid.cjs" 2321 + }, 2322 + "engines": { 2323 + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" 2324 + } 2325 + }, 2326 + "node_modules/obug": { 2327 + "version": "2.1.1", 2328 + "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz", 2329 + "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==", 2330 + "dev": true, 2331 + "funding": [ 2332 + "https://github.com/sponsors/sxzz", 2333 + "https://opencollective.com/debug" 2334 + ], 2335 + "license": "MIT" 2336 + }, 1467 2337 "node_modules/path-to-regexp": { 1468 2338 "version": "6.3.0", 1469 2339 "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz", ··· 1478 2348 "dev": true, 1479 2349 "license": "MIT" 1480 2350 }, 2351 + "node_modules/picocolors": { 2352 + "version": "1.1.1", 2353 + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", 2354 + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", 2355 + "dev": true, 2356 + "license": "ISC" 2357 + }, 2358 + "node_modules/picomatch": { 2359 + "version": "4.0.3", 2360 + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", 2361 + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", 2362 + "dev": true, 2363 + "license": "MIT", 2364 + "engines": { 2365 + "node": ">=12" 2366 + }, 2367 + "funding": { 2368 + "url": "https://github.com/sponsors/jonschlinkert" 2369 + } 2370 + }, 2371 + "node_modules/postcss": { 2372 + "version": "8.5.6", 2373 + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", 2374 + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", 2375 + "dev": true, 2376 + "funding": [ 2377 + { 2378 + "type": "opencollective", 2379 + "url": "https://opencollective.com/postcss/" 2380 + }, 2381 + { 2382 + "type": "tidelift", 2383 + "url": "https://tidelift.com/funding/github/npm/postcss" 2384 + }, 2385 + { 2386 + "type": "github", 2387 + "url": "https://github.com/sponsors/ai" 2388 + } 2389 + ], 2390 + "license": "MIT", 2391 + "dependencies": { 2392 + "nanoid": "^3.3.11", 2393 + "picocolors": "^1.1.1", 2394 + "source-map-js": "^1.2.1" 2395 + }, 2396 + "engines": { 2397 + "node": "^10 || ^12 || >=14" 2398 + } 2399 + }, 2400 + "node_modules/rollup": { 2401 + "version": "4.55.1", 2402 + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.55.1.tgz", 2403 + "integrity": "sha512-wDv/Ht1BNHB4upNbK74s9usvl7hObDnvVzknxqY/E/O3X6rW1U1rV1aENEfJ54eFZDTNo7zv1f5N4edCluH7+A==", 2404 + "dev": true, 2405 + "license": "MIT", 2406 + "dependencies": { 2407 + "@types/estree": "1.0.8" 2408 + }, 2409 + "bin": { 2410 + "rollup": "dist/bin/rollup" 2411 + }, 2412 + "engines": { 2413 + "node": ">=18.0.0", 2414 + "npm": ">=8.0.0" 2415 + }, 2416 + "optionalDependencies": { 2417 + "@rollup/rollup-android-arm-eabi": "4.55.1", 2418 + "@rollup/rollup-android-arm64": "4.55.1", 2419 + "@rollup/rollup-darwin-arm64": "4.55.1", 2420 + "@rollup/rollup-darwin-x64": "4.55.1", 2421 + "@rollup/rollup-freebsd-arm64": "4.55.1", 2422 + "@rollup/rollup-freebsd-x64": "4.55.1", 2423 + "@rollup/rollup-linux-arm-gnueabihf": "4.55.1", 2424 + "@rollup/rollup-linux-arm-musleabihf": "4.55.1", 2425 + "@rollup/rollup-linux-arm64-gnu": "4.55.1", 2426 + "@rollup/rollup-linux-arm64-musl": "4.55.1", 2427 + "@rollup/rollup-linux-loong64-gnu": "4.55.1", 2428 + "@rollup/rollup-linux-loong64-musl": "4.55.1", 2429 + "@rollup/rollup-linux-ppc64-gnu": "4.55.1", 2430 + "@rollup/rollup-linux-ppc64-musl": "4.55.1", 2431 + "@rollup/rollup-linux-riscv64-gnu": "4.55.1", 2432 + "@rollup/rollup-linux-riscv64-musl": "4.55.1", 2433 + "@rollup/rollup-linux-s390x-gnu": "4.55.1", 2434 + "@rollup/rollup-linux-x64-gnu": "4.55.1", 2435 + "@rollup/rollup-linux-x64-musl": "4.55.1", 2436 + "@rollup/rollup-openbsd-x64": "4.55.1", 2437 + "@rollup/rollup-openharmony-arm64": "4.55.1", 2438 + "@rollup/rollup-win32-arm64-msvc": "4.55.1", 2439 + "@rollup/rollup-win32-ia32-msvc": "4.55.1", 2440 + "@rollup/rollup-win32-x64-gnu": "4.55.1", 2441 + "@rollup/rollup-win32-x64-msvc": "4.55.1", 2442 + "fsevents": "~2.3.2" 2443 + } 2444 + }, 1481 2445 "node_modules/semver": { 1482 2446 "version": "7.7.3", 1483 2447 "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", ··· 1531 2495 "@img/sharp-win32-x64": "0.33.5" 1532 2496 } 1533 2497 }, 2498 + "node_modules/siginfo": { 2499 + "version": "2.0.0", 2500 + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", 2501 + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", 2502 + "dev": true, 2503 + "license": "ISC" 2504 + }, 1534 2505 "node_modules/simple-swizzle": { 1535 2506 "version": "0.2.4", 1536 2507 "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.4.tgz", ··· 1541 2512 "is-arrayish": "^0.3.1" 1542 2513 } 1543 2514 }, 2515 + "node_modules/source-map-js": { 2516 + "version": "1.2.1", 2517 + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", 2518 + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", 2519 + "dev": true, 2520 + "license": "BSD-3-Clause", 2521 + "engines": { 2522 + "node": ">=0.10.0" 2523 + } 2524 + }, 2525 + "node_modules/stackback": { 2526 + "version": "0.0.2", 2527 + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", 2528 + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", 2529 + "dev": true, 2530 + "license": "MIT" 2531 + }, 2532 + "node_modules/std-env": { 2533 + "version": "3.10.0", 2534 + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz", 2535 + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", 2536 + "dev": true, 2537 + "license": "MIT" 2538 + }, 1544 2539 "node_modules/stoppable": { 1545 2540 "version": "1.1.0", 1546 2541 "resolved": "https://registry.npmjs.org/stoppable/-/stoppable-1.1.0.tgz", ··· 1565 2560 "url": "https://github.com/chalk/supports-color?sponsor=1" 1566 2561 } 1567 2562 }, 2563 + "node_modules/tinybench": { 2564 + "version": "2.9.0", 2565 + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", 2566 + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", 2567 + "dev": true, 2568 + "license": "MIT" 2569 + }, 2570 + "node_modules/tinyexec": { 2571 + "version": "1.0.2", 2572 + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz", 2573 + "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==", 2574 + "dev": true, 2575 + "license": "MIT", 2576 + "engines": { 2577 + "node": ">=18" 2578 + } 2579 + }, 2580 + "node_modules/tinyglobby": { 2581 + "version": "0.2.15", 2582 + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", 2583 + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", 2584 + "dev": true, 2585 + "license": "MIT", 2586 + "dependencies": { 2587 + "fdir": "^6.5.0", 2588 + "picomatch": "^4.0.3" 2589 + }, 2590 + "engines": { 2591 + "node": ">=12.0.0" 2592 + }, 2593 + "funding": { 2594 + "url": "https://github.com/sponsors/SuperchupuDev" 2595 + } 2596 + }, 2597 + "node_modules/tinyrainbow": { 2598 + "version": "3.0.3", 2599 + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz", 2600 + "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==", 2601 + "dev": true, 2602 + "license": "MIT", 2603 + "engines": { 2604 + "node": ">=14.0.0" 2605 + } 2606 + }, 1568 2607 "node_modules/tslib": { 1569 2608 "version": "2.8.1", 1570 2609 "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", ··· 1605 2644 "license": "MIT", 1606 2645 "dependencies": { 1607 2646 "pathe": "^2.0.3" 2647 + } 2648 + }, 2649 + "node_modules/vite": { 2650 + "version": "7.3.1", 2651 + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz", 2652 + "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", 2653 + "dev": true, 2654 + "license": "MIT", 2655 + "dependencies": { 2656 + "esbuild": "^0.27.0", 2657 + "fdir": "^6.5.0", 2658 + "picomatch": "^4.0.3", 2659 + "postcss": "^8.5.6", 2660 + "rollup": "^4.43.0", 2661 + "tinyglobby": "^0.2.15" 2662 + }, 2663 + "bin": { 2664 + "vite": "bin/vite.js" 2665 + }, 2666 + "engines": { 2667 + "node": "^20.19.0 || >=22.12.0" 2668 + }, 2669 + "funding": { 2670 + "url": "https://github.com/vitejs/vite?sponsor=1" 2671 + }, 2672 + "optionalDependencies": { 2673 + "fsevents": "~2.3.3" 2674 + }, 2675 + "peerDependencies": { 2676 + "@types/node": "^20.19.0 || >=22.12.0", 2677 + "jiti": ">=1.21.0", 2678 + "less": "^4.0.0", 2679 + "lightningcss": "^1.21.0", 2680 + "sass": "^1.70.0", 2681 + "sass-embedded": "^1.70.0", 2682 + "stylus": ">=0.54.8", 2683 + "sugarss": "^5.0.0", 2684 + "terser": "^5.16.0", 2685 + "tsx": "^4.8.1", 2686 + "yaml": "^2.4.2" 2687 + }, 2688 + "peerDependenciesMeta": { 2689 + "@types/node": { 2690 + "optional": true 2691 + }, 2692 + "jiti": { 2693 + "optional": true 2694 + }, 2695 + "less": { 2696 + "optional": true 2697 + }, 2698 + "lightningcss": { 2699 + "optional": true 2700 + }, 2701 + "sass": { 2702 + "optional": true 2703 + }, 2704 + "sass-embedded": { 2705 + "optional": true 2706 + }, 2707 + "stylus": { 2708 + "optional": true 2709 + }, 2710 + "sugarss": { 2711 + "optional": true 2712 + }, 2713 + "terser": { 2714 + "optional": true 2715 + }, 2716 + "tsx": { 2717 + "optional": true 2718 + }, 2719 + "yaml": { 2720 + "optional": true 2721 + } 2722 + } 2723 + }, 2724 + "node_modules/vitest": { 2725 + "version": "4.0.16", 2726 + "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.16.tgz", 2727 + "integrity": "sha512-E4t7DJ9pESL6E3I8nFjPa4xGUd3PmiWDLsDztS2qXSJWfHtbQnwAWylaBvSNY48I3vr8PTqIZlyK8TE3V3CA4Q==", 2728 + "dev": true, 2729 + "license": "MIT", 2730 + "dependencies": { 2731 + "@vitest/expect": "4.0.16", 2732 + "@vitest/mocker": "4.0.16", 2733 + "@vitest/pretty-format": "4.0.16", 2734 + "@vitest/runner": "4.0.16", 2735 + "@vitest/snapshot": "4.0.16", 2736 + "@vitest/spy": "4.0.16", 2737 + "@vitest/utils": "4.0.16", 2738 + "es-module-lexer": "^1.7.0", 2739 + "expect-type": "^1.2.2", 2740 + "magic-string": "^0.30.21", 2741 + "obug": "^2.1.1", 2742 + "pathe": "^2.0.3", 2743 + "picomatch": "^4.0.3", 2744 + "std-env": "^3.10.0", 2745 + "tinybench": "^2.9.0", 2746 + "tinyexec": "^1.0.2", 2747 + "tinyglobby": "^0.2.15", 2748 + "tinyrainbow": "^3.0.3", 2749 + "vite": "^6.0.0 || ^7.0.0", 2750 + "why-is-node-running": "^2.3.0" 2751 + }, 2752 + "bin": { 2753 + "vitest": "vitest.mjs" 2754 + }, 2755 + "engines": { 2756 + "node": "^20.0.0 || ^22.0.0 || >=24.0.0" 2757 + }, 2758 + "funding": { 2759 + "url": "https://opencollective.com/vitest" 2760 + }, 2761 + "peerDependencies": { 2762 + "@edge-runtime/vm": "*", 2763 + "@opentelemetry/api": "^1.9.0", 2764 + "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", 2765 + "@vitest/browser-playwright": "4.0.16", 2766 + "@vitest/browser-preview": "4.0.16", 2767 + "@vitest/browser-webdriverio": "4.0.16", 2768 + "@vitest/ui": "4.0.16", 2769 + "happy-dom": "*", 2770 + "jsdom": "*" 2771 + }, 2772 + "peerDependenciesMeta": { 2773 + "@edge-runtime/vm": { 2774 + "optional": true 2775 + }, 2776 + "@opentelemetry/api": { 2777 + "optional": true 2778 + }, 2779 + "@types/node": { 2780 + "optional": true 2781 + }, 2782 + "@vitest/browser-playwright": { 2783 + "optional": true 2784 + }, 2785 + "@vitest/browser-preview": { 2786 + "optional": true 2787 + }, 2788 + "@vitest/browser-webdriverio": { 2789 + "optional": true 2790 + }, 2791 + "@vitest/ui": { 2792 + "optional": true 2793 + }, 2794 + "happy-dom": { 2795 + "optional": true 2796 + }, 2797 + "jsdom": { 2798 + "optional": true 2799 + } 2800 + } 2801 + }, 2802 + "node_modules/why-is-node-running": { 2803 + "version": "2.3.0", 2804 + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", 2805 + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", 2806 + "dev": true, 2807 + "license": "MIT", 2808 + "dependencies": { 2809 + "siginfo": "^2.0.0", 2810 + "stackback": "0.0.2" 2811 + }, 2812 + "bin": { 2813 + "why-is-node-running": "cli.js" 2814 + }, 2815 + "engines": { 2816 + "node": ">=8" 1608 2817 } 1609 2818 }, 1610 2819 "node_modules/workerd": {
+5 -1
package.json
··· 7 7 "dev": "wrangler dev --persist-to .wrangler/state", 8 8 "dev:remote": "wrangler dev --remote", 9 9 "deploy": "wrangler deploy", 10 - "test": "node --test test/pds.test.js", 10 + "test": "vitest run", 11 + "test:watch": "vitest", 12 + "test:coverage": "vitest run --coverage", 11 13 "test:e2e": "node --test test/e2e.test.js", 12 14 "setup": "node scripts/setup.js", 13 15 "format": "biome format --write .", ··· 18 20 "devDependencies": { 19 21 "@biomejs/biome": "^2.3.11", 20 22 "@cloudflare/workers-types": "^4.20260103.0", 23 + "@vitest/coverage-v8": "^4.0.16", 21 24 "typescript": "^5.9.3", 25 + "vitest": "^4.0.16", 22 26 "wrangler": "^4.54.0" 23 27 } 24 28 }
+179 -258
test/e2e.test.js
··· 3 3 * Uses Node's built-in test runner and fetch 4 4 */ 5 5 6 - import assert from 'node:assert'; 7 6 import { spawn } from 'node:child_process'; 8 7 import { randomBytes } from 'node:crypto'; 9 - import { after, before, describe, it } from 'node:test'; 8 + import { afterAll, beforeAll, describe, it, expect } from 'vitest'; 10 9 import { DpopClient } from './helpers/dpop.js'; 11 10 import { getOAuthTokenWithScope } from './helpers/oauth.js'; 12 11 ··· 88 87 } 89 88 90 89 describe('E2E Tests', () => { 91 - before(async () => { 90 + beforeAll(async () => { 92 91 // Start wrangler 93 92 wrangler = spawn( 94 93 'npx', ··· 112 111 handle: 'test.local', 113 112 }), 114 113 }); 115 - assert.ok(res.ok, 'PDS initialization failed'); 114 + expect(res.ok).toBeTruthy(); 116 115 }); 117 116 118 - after(() => { 117 + afterAll(() => { 119 118 if (wrangler) { 120 119 wrangler.kill(); 121 120 } ··· 125 124 it('root returns ASCII art', async () => { 126 125 const res = await fetch(`${BASE}/`); 127 126 const text = await res.text(); 128 - assert.ok(text.includes('PDS'), 'Root should contain PDS'); 127 + expect(text.includes('PDS')).toBeTruthy(); // Root should contain PDS; 129 128 }); 130 129 131 130 it('describeServer returns DID', async () => { 132 131 const res = await fetch(`${BASE}/xrpc/com.atproto.server.describeServer`); 133 132 const data = await res.json(); 134 - assert.ok(data.did, 'describeServer should return did'); 133 + expect(data.did).toBeTruthy(); 135 134 }); 136 135 137 136 it('resolveHandle returns DID', async () => { ··· 139 138 `${BASE}/xrpc/com.atproto.identity.resolveHandle?handle=test.local`, 140 139 ); 141 140 const data = await res.json(); 142 - assert.ok(data.did, 'resolveHandle should return did'); 141 + expect(data.did).toBeTruthy(); 143 142 }); 144 143 }); 145 144 ··· 152 151 password: PASSWORD, 153 152 }, 154 153 ); 155 - assert.strictEqual(status, 200); 156 - assert.ok(data.accessJwt, 'Should return accessJwt'); 157 - assert.ok(data.refreshJwt, 'Should return refreshJwt'); 154 + expect(status).toBe(200); 155 + expect(data.accessJwt).toBeTruthy(); 156 + expect(data.refreshJwt).toBeTruthy(); 158 157 token = data.accessJwt; 159 158 refreshToken = data.refreshJwt; 160 159 }); ··· 164 163 headers: { Authorization: `Bearer ${token}` }, 165 164 }); 166 165 const data = await res.json(); 167 - assert.ok(data.did, 'getSession should return did'); 166 + expect(data.did).toBeTruthy(); 168 167 }); 169 168 170 169 it('refreshSession returns new tokens', async () => { ··· 176 175 }, 177 176 ); 178 177 const data = await res.json(); 179 - assert.ok(data.accessJwt, 'Should return new accessJwt'); 180 - assert.ok(data.refreshJwt, 'Should return new refreshJwt'); 178 + expect(data.accessJwt).toBeTruthy(); 179 + expect(data.refreshJwt).toBeTruthy(); 181 180 token = data.accessJwt; // Use new token 182 181 }); 183 182 ··· 189 188 headers: { Authorization: `Bearer ${token}` }, 190 189 }, 191 190 ); 192 - assert.strictEqual(res.status, 400); 191 + expect(res.status).toBe(400); 193 192 }); 194 193 195 194 it('refreshSession rejects missing auth', async () => { ··· 199 198 method: 'POST', 200 199 }, 201 200 ); 202 - assert.strictEqual(res.status, 401); 201 + expect(res.status).toBe(401); 203 202 }); 204 203 205 204 it('createRecord rejects without auth', async () => { ··· 208 207 collection: 'x', 209 208 record: {}, 210 209 }); 211 - assert.strictEqual(status, 401); 210 + expect(status).toBe(401); 212 211 }); 213 212 214 213 it('getPreferences works', async () => { ··· 216 215 headers: { Authorization: `Bearer ${token}` }, 217 216 }); 218 217 const data = await res.json(); 219 - assert.ok(data.preferences, 'Should return preferences'); 218 + expect(data.preferences).toBeTruthy(); 220 219 }); 221 220 222 221 it('putPreferences works', async () => { ··· 225 224 { preferences: [{ $type: 'app.bsky.actor.defs#savedFeedsPrefV2' }] }, 226 225 { Authorization: `Bearer ${token}` }, 227 226 ); 228 - assert.strictEqual(status, 200); 227 + expect(status).toBe(200); 229 228 }); 230 229 }); 231 230 ··· 240 239 }, 241 240 { Authorization: `Bearer ${token}` }, 242 241 ); 243 - assert.strictEqual(status, 200); 244 - assert.ok(data.uri, 'Should return uri'); 242 + expect(status).toBe(200); 243 + expect(data.uri).toBeTruthy(); 245 244 testRkey = data.uri.split('/').pop(); 246 245 }); 247 246 ··· 250 249 `${BASE}/xrpc/com.atproto.repo.getRecord?repo=${DID}&collection=app.bsky.feed.post&rkey=${testRkey}`, 251 250 ); 252 251 const data = await res.json(); 253 - assert.ok(data.value?.text, 'Should return record value'); 252 + expect(data.value?.text).toBeTruthy(); 254 253 }); 255 254 256 255 it('putRecord updates record', async () => { ··· 264 263 }, 265 264 { Authorization: `Bearer ${token}` }, 266 265 ); 267 - assert.strictEqual(status, 200); 268 - assert.ok(data.uri); 266 + expect(status).toBe(200); 267 + expect(data.uri).toBeTruthy(); 269 268 }); 270 269 271 270 it('listRecords returns records', async () => { ··· 273 272 `${BASE}/xrpc/com.atproto.repo.listRecords?repo=${DID}&collection=app.bsky.feed.post`, 274 273 ); 275 274 const data = await res.json(); 276 - assert.ok(data.records?.length > 0, 'Should return records'); 275 + expect(data.records?.length > 0).toBeTruthy(); 277 276 }); 278 277 279 278 it('describeRepo returns did', async () => { ··· 281 280 `${BASE}/xrpc/com.atproto.repo.describeRepo?repo=${DID}`, 282 281 ); 283 282 const data = await res.json(); 284 - assert.ok(data.did); 283 + expect(data.did).toBeTruthy(); 285 284 }); 286 285 287 286 it('applyWrites create', async () => { ··· 300 299 }, 301 300 { Authorization: `Bearer ${token}` }, 302 301 ); 303 - assert.strictEqual(status, 200); 304 - assert.ok(data.results); 302 + expect(status).toBe(200); 303 + expect(data.results).toBeTruthy(); 305 304 }); 306 305 307 306 it('applyWrites delete', async () => { ··· 319 318 }, 320 319 { Authorization: `Bearer ${token}` }, 321 320 ); 322 - assert.strictEqual(status, 200); 323 - assert.ok(data.results); 321 + expect(status).toBe(200); 322 + expect(data.results).toBeTruthy(); 324 323 }); 325 324 }); 326 325 ··· 330 329 `${BASE}/xrpc/com.atproto.sync.getLatestCommit?did=${DID}`, 331 330 ); 332 331 const data = await res.json(); 333 - assert.ok(data.cid); 332 + expect(data.cid).toBeTruthy(); 334 333 }); 335 334 336 335 it('getRepoStatus returns did', async () => { ··· 338 337 `${BASE}/xrpc/com.atproto.sync.getRepoStatus?did=${DID}`, 339 338 ); 340 339 const data = await res.json(); 341 - assert.ok(data.did); 340 + expect(data.did).toBeTruthy(); 342 341 }); 343 342 344 343 it('getRepo returns CAR', async () => { ··· 346 345 `${BASE}/xrpc/com.atproto.sync.getRepo?did=${DID}`, 347 346 ); 348 347 const data = await res.arrayBuffer(); 349 - assert.ok(data.byteLength > 100, 'Should return CAR data'); 348 + expect(data.byteLength > 100).toBeTruthy(); 350 349 }); 351 350 352 351 it('getRecord returns record CAR', async () => { ··· 354 353 `${BASE}/xrpc/com.atproto.sync.getRecord?did=${DID}&collection=app.bsky.feed.post&rkey=${testRkey}`, 355 354 ); 356 355 const data = await res.arrayBuffer(); 357 - assert.ok(data.byteLength > 50); 356 + expect(data.byteLength > 50).toBeTruthy(); 358 357 }); 359 358 360 359 it('listRepos returns repos', async () => { 361 360 const res = await fetch(`${BASE}/xrpc/com.atproto.sync.listRepos`); 362 361 const data = await res.json(); 363 - assert.ok(data.repos?.length > 0); 362 + expect(data.repos?.length > 0).toBeTruthy(); 364 363 }); 365 364 }); 366 365 ··· 373 372 password: 'wrong-password', 374 373 }, 375 374 ); 376 - assert.strictEqual(status, 401); 375 + expect(status).toBe(401); 377 376 }); 378 377 379 378 it('wrong repo rejected (403)', async () => { ··· 386 385 }, 387 386 { Authorization: `Bearer ${token}` }, 388 387 ); 389 - assert.strictEqual(status, 403); 388 + expect(status).toBe(403); 390 389 }); 391 390 392 391 it('non-existent record errors', async () => { 393 392 const res = await fetch( 394 393 `${BASE}/xrpc/com.atproto.repo.getRecord?repo=${DID}&collection=app.bsky.feed.post&rkey=nonexistent`, 395 394 ); 396 - assert.ok([400, 404].includes(res.status)); 395 + expect([400, 404].includes(res.status)).toBeTruthy(); 397 396 }); 398 397 }); 399 398 ··· 419 418 headers: { 'Content-Type': 'image/png' }, 420 419 body: pngBytes, 421 420 }); 422 - assert.strictEqual(res.status, 401); 421 + expect(res.status).toBe(401); 423 422 }); 424 423 425 424 it('uploadBlob returns CID', async () => { ··· 432 431 body: pngBytes, 433 432 }); 434 433 const data = await res.json(); 435 - assert.ok(data.blob?.ref?.$link); 436 - assert.strictEqual(data.blob?.mimeType, 'image/png'); 434 + expect(data.blob?.ref?.$link).toBeTruthy(); 435 + expect(data.blob?.mimeType).toBe('image/png'); 437 436 blobCid = data.blob.ref.$link; 438 437 }); 439 438 ··· 442 441 `${BASE}/xrpc/com.atproto.sync.listBlobs?did=${DID}`, 443 442 ); 444 443 const data = await res.json(); 445 - assert.ok(data.cids?.includes(blobCid)); 444 + expect(data.cids?.includes(blobCid)).toBeTruthy();; 446 445 }); 447 446 448 447 it('getBlob retrieves data', async () => { 449 448 const res = await fetch( 450 449 `${BASE}/xrpc/com.atproto.sync.getBlob?did=${DID}&cid=${blobCid}`, 451 450 ); 452 - assert.ok(res.ok); 453 - assert.strictEqual(res.headers.get('content-type'), 'image/png'); 454 - assert.strictEqual(res.headers.get('x-content-type-options'), 'nosniff'); 451 + expect(res.ok).toBeTruthy(); 452 + expect(res.headers.get('content-type')).toBe('image/png'); 453 + expect(res.headers.get('x-content-type-options')).toBe('nosniff'); 455 454 }); 456 455 457 456 it('getBlob rejects wrong DID', async () => { 458 457 const res = await fetch( 459 458 `${BASE}/xrpc/com.atproto.sync.getBlob?did=did:plc:wrongdid&cid=${blobCid}`, 460 459 ); 461 - assert.strictEqual(res.status, 400); 460 + expect(res.status).toBe(400); 462 461 }); 463 462 464 463 it('getBlob rejects invalid CID', async () => { 465 464 const res = await fetch( 466 465 `${BASE}/xrpc/com.atproto.sync.getBlob?did=${DID}&cid=invalid`, 467 466 ); 468 - assert.strictEqual(res.status, 400); 467 + expect(res.status).toBe(400); 469 468 }); 470 469 471 470 it('getBlob 404 for missing blob', async () => { 472 471 const res = await fetch( 473 472 `${BASE}/xrpc/com.atproto.sync.getBlob?did=${DID}&cid=bafkreiaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`, 474 473 ); 475 - assert.strictEqual(res.status, 404); 474 + expect(res.status).toBe(404); 476 475 }); 477 476 478 477 it('createRecord with blob ref', async () => { ··· 502 501 }, 503 502 { Authorization: `Bearer ${token}` }, 504 503 ); 505 - assert.strictEqual(status, 200); 504 + expect(status).toBe(200); 506 505 blobPostRkey = data.uri.split('/').pop(); 507 506 }); 508 507 ··· 511 510 `${BASE}/xrpc/com.atproto.sync.listBlobs?did=${DID}`, 512 511 ); 513 512 const data = await res.json(); 514 - assert.ok(data.cids?.includes(blobCid)); 513 + expect(data.cids?.includes(blobCid)).toBeTruthy();; 515 514 }); 516 515 517 516 it('deleteRecord with blob cleans up', async () => { ··· 520 519 { repo: DID, collection: 'app.bsky.feed.post', rkey: blobPostRkey }, 521 520 { Authorization: `Bearer ${token}` }, 522 521 ); 523 - assert.strictEqual(status, 200); 522 + expect(status).toBe(200); 524 523 525 524 const res = await fetch( 526 525 `${BASE}/xrpc/com.atproto.sync.listBlobs?did=${DID}`, 527 526 ); 528 527 const data = await res.json(); 529 - assert.strictEqual( 530 - data.cids?.length, 531 - 0, 532 - 'Orphaned blob should be cleaned up', 533 - ); 528 + expect( 529 + data.cids?.length).toBe(0); 534 530 }); 535 531 }); 536 532 ··· 538 534 it('AS metadata', async () => { 539 535 const res = await fetch(`${BASE}/.well-known/oauth-authorization-server`); 540 536 const data = await res.json(); 541 - assert.strictEqual(data.issuer, BASE); 542 - assert.strictEqual( 543 - data.authorization_endpoint, 544 - `${BASE}/oauth/authorize`, 545 - ); 546 - assert.strictEqual(data.token_endpoint, `${BASE}/oauth/token`); 547 - assert.strictEqual( 548 - data.pushed_authorization_request_endpoint, 549 - `${BASE}/oauth/par`, 550 - ); 551 - assert.strictEqual(data.revocation_endpoint, `${BASE}/oauth/revoke`); 552 - assert.strictEqual(data.jwks_uri, `${BASE}/oauth/jwks`); 553 - assert.deepStrictEqual(data.scopes_supported, ['atproto']); 554 - assert.deepStrictEqual(data.dpop_signing_alg_values_supported, ['ES256']); 555 - assert.strictEqual(data.require_pushed_authorization_requests, false); 556 - assert.strictEqual(data.client_id_metadata_document_supported, true); 557 - assert.deepStrictEqual(data.protected_resources, [BASE]); 537 + expect(data.issuer).toBe(BASE); 538 + expect(data.authorization_endpoint).toBe(`${BASE}/oauth/authorize`); 539 + expect(data.token_endpoint).toBe(`${BASE}/oauth/token`); 540 + expect(data.pushed_authorization_request_endpoint).toBe(`${BASE}/oauth/par`); 541 + expect(data.revocation_endpoint).toBe(`${BASE}/oauth/revoke`); 542 + expect(data.jwks_uri).toBe(`${BASE}/oauth/jwks`); 543 + expect(data.scopes_supported).toEqual(['atproto']); 544 + expect(data.dpop_signing_alg_values_supported).toEqual(['ES256']); 545 + expect(data.require_pushed_authorization_requests).toBe(false); 546 + expect(data.client_id_metadata_document_supported).toBe(true); 547 + expect(data.protected_resources).toEqual([BASE]); 558 548 }); 559 549 560 550 it('PR metadata', async () => { 561 551 const res = await fetch(`${BASE}/.well-known/oauth-protected-resource`); 562 552 const data = await res.json(); 563 - assert.strictEqual(data.resource, BASE); 564 - assert.deepStrictEqual(data.authorization_servers, [BASE]); 553 + expect(data.resource).toBe(BASE); 554 + expect(data.authorization_servers).toEqual([BASE]); 565 555 }); 566 556 567 557 it('JWKS endpoint', async () => { 568 558 const res = await fetch(`${BASE}/oauth/jwks`); 569 559 const data = await res.json(); 570 - assert.ok(data.keys?.length > 0); 560 + expect(data.keys?.length > 0).toBeTruthy(); 571 561 const key = data.keys[0]; 572 - assert.strictEqual(key.kty, 'EC'); 573 - assert.strictEqual(key.crv, 'P-256'); 574 - assert.strictEqual(key.alg, 'ES256'); 575 - assert.strictEqual(key.use, 'sig'); 576 - assert.ok(key.x && key.y, 'Should have x,y coords'); 577 - assert.ok(!key.d, 'Should not expose private key'); 562 + expect(key.kty).toBe('EC'); 563 + expect(key.crv).toBe('P-256'); 564 + expect(key.alg).toBe('ES256'); 565 + expect(key.use).toBe('sig'); 566 + expect(key.x && key.y).toBeTruthy(); 567 + expect(!key.d).toBeTruthy(); 578 568 }); 579 569 580 570 it('PAR rejects missing DPoP', async () => { ··· 586 576 code_challenge: 'test', 587 577 code_challenge_method: 'S256', 588 578 }); 589 - assert.strictEqual(status, 400); 590 - assert.strictEqual(data.error, 'invalid_dpop_proof'); 579 + expect(status).toBe(400); 580 + expect(data.error).toBe('invalid_dpop_proof'); 591 581 }); 592 582 593 583 it('token rejects missing DPoP', async () => { ··· 596 586 code: 'fake', 597 587 client_id: 'http://localhost:3000', 598 588 }); 599 - assert.strictEqual(status, 400); 600 - assert.strictEqual(data.error, 'invalid_dpop_proof'); 589 + expect(status).toBe(400); 590 + expect(data.error).toBe('invalid_dpop_proof'); 601 591 }); 602 592 603 593 it('revoke returns 200 for invalid token', async () => { ··· 605 595 token: 'nonexistent', 606 596 client_id: 'http://localhost:3000', 607 597 }); 608 - assert.strictEqual(status, 200); 598 + expect(status).toBe(200); 609 599 }); 610 600 }); 611 601 ··· 643 633 }).toString(), 644 634 }); 645 635 646 - assert.strictEqual(parRes.status, 200, 'PAR should succeed'); 636 + expect(parRes.status).toBe(200); 647 637 const parData = await parRes.json(); 648 - assert.ok(parData.request_uri, 'PAR should return request_uri'); 649 - assert.ok(parData.expires_in > 0, 'PAR should return expires_in'); 638 + expect(parData.request_uri).toBeTruthy(); 639 + expect(parData.expires_in > 0).toBeTruthy(); 650 640 651 641 // Step 2: Authorization (simulate user consent by POSTing to authorize) 652 642 const authRes = await fetch(`${BASE}/oauth/authorize`, { ··· 660 650 redirect: 'manual', 661 651 }); 662 652 663 - assert.strictEqual(authRes.status, 302, 'Authorize should redirect'); 653 + expect(authRes.status).toBe(302); 664 654 const location = authRes.headers.get('location'); 665 - assert.ok(location, 'Should have Location header'); 655 + expect(location).toBeTruthy(); 666 656 667 657 const redirectUrl = new URL(location); 668 658 const authCode = redirectUrl.searchParams.get('code'); 669 - assert.ok(authCode, 'Redirect should have code'); 670 - assert.strictEqual(redirectUrl.searchParams.get('state'), 'test-state'); 671 - assert.strictEqual(redirectUrl.searchParams.get('iss'), BASE); 659 + expect(authCode).toBeTruthy(); 660 + expect(redirectUrl.searchParams.get('state')).toBe('test-state'); 661 + expect(redirectUrl.searchParams.get('iss')).toBe(BASE); 672 662 673 663 // Step 3: Token exchange 674 664 const tokenProof = await dpop.createProof('POST', `${BASE}/oauth/token`); ··· 687 677 }).toString(), 688 678 }); 689 679 690 - assert.strictEqual(tokenRes.status, 200, 'Token exchange should succeed'); 680 + expect(tokenRes.status).toBe(200); 691 681 const tokenData = await tokenRes.json(); 692 - assert.ok(tokenData.access_token, 'Should return access_token'); 693 - assert.ok(tokenData.refresh_token, 'Should return refresh_token'); 694 - assert.strictEqual(tokenData.token_type, 'DPoP'); 695 - assert.strictEqual(tokenData.scope, 'atproto'); 696 - assert.ok(tokenData.sub, 'Should return sub'); 682 + expect(tokenData.access_token).toBeTruthy(); 683 + expect(tokenData.refresh_token).toBeTruthy(); 684 + expect(tokenData.token_type).toBe('DPoP'); 685 + expect(tokenData.scope).toBe('atproto'); 686 + expect(tokenData.sub).toBeTruthy(); 697 687 698 688 // Step 4: Use access token with DPoP for protected endpoint 699 689 const resourceProof = await dpop.createProof( ··· 711 701 }, 712 702 ); 713 703 714 - assert.strictEqual( 715 - sessionRes.status, 716 - 200, 717 - 'Protected endpoint should work with DPoP token', 718 - ); 704 + expect( 705 + sessionRes.status).toBe(200); 719 706 const sessionData = await sessionRes.json(); 720 - assert.ok(sessionData.did, 'Should return session data'); 707 + expect(sessionData.did).toBeTruthy(); 721 708 722 709 // Step 5: Refresh token 723 710 const refreshProof = await dpop.createProof( ··· 737 724 }).toString(), 738 725 }); 739 726 740 - assert.strictEqual(refreshRes.status, 200, 'Refresh should succeed'); 727 + expect(refreshRes.status).toBe(200); 741 728 const refreshData = await refreshRes.json(); 742 - assert.ok(refreshData.access_token, 'Should return new access_token'); 743 - assert.ok(refreshData.refresh_token, 'Should return new refresh_token'); 729 + expect(refreshData.access_token).toBeTruthy(); 730 + expect(refreshData.refresh_token).toBeTruthy(); 744 731 745 732 // Step 6: Revoke token 746 733 const revokeRes = await fetch(`${BASE}/oauth/revoke`, { ··· 751 738 client_id: clientId, 752 739 }).toString(), 753 740 }); 754 - assert.strictEqual(revokeRes.status, 200); 741 + expect(revokeRes.status).toBe(200); 755 742 }); 756 743 757 744 it('DPoP key mismatch rejected', async () => { ··· 817 804 }).toString(), 818 805 }); 819 806 820 - assert.strictEqual(tokenRes.status, 400); 807 + expect(tokenRes.status).toBe(400); 821 808 const tokenData = await tokenRes.json(); 822 - assert.strictEqual(tokenData.error, 'invalid_dpop_proof'); 809 + expect(tokenData.error).toBe('invalid_dpop_proof'); 823 810 }); 824 811 825 812 it('fragment response_mode returns code in fragment', async () => { ··· 853 840 }).toString(), 854 841 }); 855 842 const parData = await parRes.json(); 856 - assert.ok(parData.request_uri); 843 + expect(parData.request_uri).toBeTruthy(); 857 844 858 845 // Authorize 859 846 const authRes = await fetch(`${BASE}/oauth/authorize`, { ··· 867 854 redirect: 'manual', 868 855 }); 869 856 870 - assert.strictEqual(authRes.status, 302); 857 + expect(authRes.status).toBe(302); 871 858 const location = authRes.headers.get('location'); 872 - assert.ok(location); 859 + expect(location).toBeTruthy(); 873 860 // For fragment mode, code should be in hash fragment 874 - assert.ok(location.includes('#'), 'Should use fragment'); 861 + expect(location.includes('#')).toBeTruthy(); // Should use fragment; 875 862 const url = new URL(location); 876 863 const fragment = new URLSearchParams(url.hash.slice(1)); 877 - assert.ok(fragment.get('code'), 'Code should be in fragment'); 878 - assert.ok(fragment.get('iss'), 'Issuer should be in fragment'); 864 + expect(fragment.get('code')).toBeTruthy(); // Code should be in fragment; 865 + expect(fragment.get('iss')).toBeTruthy(); // Issuer should be in fragment; 879 866 }); 880 867 881 868 it('PKCE failure - wrong code_verifier rejected', async () => { ··· 941 928 }).toString(), 942 929 }); 943 930 944 - assert.strictEqual(tokenRes.status, 400); 931 + expect(tokenRes.status).toBe(400); 945 932 const tokenData = await tokenRes.json(); 946 - assert.strictEqual(tokenData.error, 'invalid_grant'); 947 - assert.ok(tokenData.message?.includes('code_verifier')); 933 + expect(tokenData.error).toBe('invalid_grant'); 934 + expect(tokenData.message?.includes('code_verifier')).toBeTruthy();; 948 935 }); 949 936 950 937 it('redirect_uri mismatch rejected', async () => { ··· 976 963 }).toString(), 977 964 }); 978 965 979 - assert.strictEqual(parRes.status, 400); 966 + expect(parRes.status).toBe(400); 980 967 const parData = await parRes.json(); 981 - assert.strictEqual(parData.error, 'invalid_request'); 982 - assert.ok(parData.message?.includes('redirect_uri')); 968 + expect(parData.error).toBe('invalid_request'); 969 + expect(parData.message?.includes('redirect_uri')).toBeTruthy();; 983 970 }); 984 971 985 972 it('DPoP jti replay rejected', async () => { ··· 1013 1000 login_hint: DID, 1014 1001 }).toString(), 1015 1002 }); 1016 - assert.strictEqual(parRes1.status, 200); 1003 + expect(parRes1.status).toBe(200); 1017 1004 1018 1005 // Second request with SAME proof should be rejected 1019 1006 const parRes2 = await fetch(`${BASE}/oauth/par`, { ··· 1033 1020 }).toString(), 1034 1021 }); 1035 1022 1036 - assert.strictEqual(parRes2.status, 400); 1023 + expect(parRes2.status).toBe(400); 1037 1024 const data = await parRes2.json(); 1038 - assert.strictEqual(data.error, 'invalid_dpop_proof'); 1039 - assert.ok(data.message?.includes('replay')); 1025 + expect(data.error).toBe('invalid_dpop_proof'); 1026 + expect(data.message?.includes('replay')).toBeTruthy();; 1040 1027 }); 1041 1028 }); 1042 1029 ··· 1069 1056 }), 1070 1057 }); 1071 1058 1072 - assert.strictEqual(res.status, 403, 'Should reject with 403'); 1059 + expect(res.status).toBe(403); 1073 1060 const body = await res.json(); 1074 - assert.ok( 1075 - body.message?.includes('Missing required scope'), 1076 - 'Error should mention missing scope', 1077 - ); 1061 + expect(body.message?.includes('Missing required scope')).toBeTruthy(); // Error should mention missing scope 1078 1062 }); 1079 1063 1080 1064 it('createRecord allowed with matching scope', async () => { ··· 1105 1089 }), 1106 1090 }); 1107 1091 1108 - assert.strictEqual(res.status, 200, 'Should allow with correct scope'); 1092 + expect(res.status).toBe(200); 1109 1093 const body = await res.json(); 1110 - assert.ok(body.uri, 'Should return uri'); 1094 + expect(body.uri).toBeTruthy(); 1111 1095 1112 1096 // Note: We don't clean up here because our token only has create scope 1113 1097 // The record will be cleaned up by subsequent tests with full-access tokens ··· 1144 1128 }), 1145 1129 }); 1146 1130 1147 - assert.strictEqual( 1148 - res.status, 1149 - 200, 1150 - 'Wildcard scope should allow any collection', 1151 - ); 1131 + expect( 1132 + res.status).toBe(200); 1152 1133 }); 1153 1134 1154 1135 it('deleteRecord denied without delete scope', async () => { ··· 1179 1160 }), 1180 1161 }); 1181 1162 1182 - assert.strictEqual( 1183 - res.status, 1184 - 403, 1185 - 'Should reject delete without delete scope', 1186 - ); 1163 + expect( 1164 + res.status).toBe(403); 1187 1165 }); 1188 1166 1189 1167 it('uploadBlob denied with mismatched MIME scope', async () => { ··· 1211 1189 body: new Uint8Array([0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70]), // Fake MP4 header 1212 1190 }); 1213 1191 1214 - assert.strictEqual( 1215 - res.status, 1216 - 403, 1217 - 'Should reject video upload with image-only scope', 1218 - ); 1192 + expect( 1193 + res.status).toBe(403); 1219 1194 const body = await res.json(); 1220 - assert.ok( 1221 - body.message?.includes('Missing required scope'), 1222 - 'Error should mention missing scope', 1223 - ); 1195 + expect(body.message?.includes('Missing required scope')).toBeTruthy(); // Error should mention missing scope 1224 1196 }); 1225 1197 1226 1198 it('uploadBlob allowed with matching MIME scope', async () => { ··· 1257 1229 body: pngBytes, 1258 1230 }); 1259 1231 1260 - assert.strictEqual( 1261 - res.status, 1262 - 200, 1263 - 'Should allow image upload with image scope', 1264 - ); 1232 + expect( 1233 + res.status).toBe(200); 1265 1234 }); 1266 1235 1267 1236 it('transition:generic grants full access', async () => { ··· 1295 1264 }), 1296 1265 }); 1297 1266 1298 - assert.strictEqual( 1299 - res.status, 1300 - 200, 1301 - 'transition:generic should grant full access', 1302 - ); 1267 + expect( 1268 + res.status).toBe(200); 1303 1269 }); 1304 1270 }); 1305 1271 ··· 1337 1303 }).toString(), 1338 1304 }); 1339 1305 1340 - assert.strictEqual(parRes.status, 200, 'PAR should succeed'); 1306 + expect(parRes.status).toBe(200); 1341 1307 const { request_uri } = await parRes.json(); 1342 1308 1343 1309 // GET the authorize page ··· 1348 1314 const html = await authorizeRes.text(); 1349 1315 1350 1316 // Verify permissions table is rendered 1351 - assert.ok( 1352 - html.includes('Repository permissions:'), 1353 - 'Should show repo permissions section', 1354 - ); 1355 - assert.ok( 1356 - html.includes('app.bsky.feed.post'), 1357 - 'Should show collection name', 1358 - ); 1359 - assert.ok( 1360 - html.includes('Upload permissions:'), 1361 - 'Should show upload permissions section', 1362 - ); 1363 - assert.ok(html.includes('image/*'), 'Should show blob MIME type'); 1317 + expect(html.includes('Repository permissions:')).toBeTruthy(); // Should show repo permissions section 1318 + expect(html.includes('app.bsky.feed.post')).toBeTruthy(); // Should show collection name 1319 + expect(html.includes('Upload permissions:')).toBeTruthy(); // Should show upload permissions section 1320 + expect(html.includes('image/*')).toBeTruthy(); // Should show blob MIME type; 1364 1321 }); 1365 1322 1366 1323 it('consent page shows identity message for atproto-only scope', async () => { ··· 1395 1352 }).toString(), 1396 1353 }); 1397 1354 1398 - assert.strictEqual(parRes.status, 200, 'PAR should succeed'); 1355 + expect(parRes.status).toBe(200); 1399 1356 const { request_uri } = await parRes.json(); 1400 1357 1401 1358 // GET the authorize page ··· 1406 1363 const html = await authorizeRes.text(); 1407 1364 1408 1365 // Verify identity-only message 1409 - assert.ok( 1410 - html.includes('wants to uniquely identify you'), 1411 - 'Should show identity-only message', 1412 - ); 1413 - assert.ok( 1414 - !html.includes('Repository permissions:'), 1415 - 'Should NOT show permissions table', 1416 - ); 1366 + expect(html.includes('wants to uniquely identify you')).toBeTruthy(); // Should show identity-only message 1367 + expect(!html.includes('Repository permissions:')).toBeTruthy(); // Should NOT show permissions table 1417 1368 }); 1418 1369 1419 1370 it('consent page shows warning for transition:generic scope', async () => { ··· 1448 1399 }).toString(), 1449 1400 }); 1450 1401 1451 - assert.strictEqual(parRes.status, 200, 'PAR should succeed'); 1402 + expect(parRes.status).toBe(200); 1452 1403 const { request_uri } = await parRes.json(); 1453 1404 1454 1405 // GET the authorize page ··· 1459 1410 const html = await authorizeRes.text(); 1460 1411 1461 1412 // Verify warning banner 1462 - assert.ok( 1463 - html.includes('Full repository access requested'), 1464 - 'Should show full access warning', 1465 - ); 1413 + expect(html.includes('Full repository access requested')).toBeTruthy(); // Should show full access warning 1466 1414 }); 1467 1415 1468 1416 it('supports direct authorization without PAR', async () => { ··· 1488 1436 authorizeUrl.searchParams.set('login_hint', DID); 1489 1437 1490 1438 const getRes = await fetch(authorizeUrl.toString()); 1491 - assert.strictEqual( 1492 - getRes.status, 1493 - 200, 1494 - 'Direct authorize GET should succeed', 1495 - ); 1439 + expect( 1440 + getRes.status).toBe(200); 1496 1441 1497 1442 const html = await getRes.text(); 1498 - assert.ok(html.includes('Authorize'), 'Should show consent page'); 1499 - assert.ok( 1500 - html.includes('request_uri'), 1501 - 'Should include request_uri in form', 1502 - ); 1443 + expect(html.includes('Authorize')).toBeTruthy(); // Should show consent page; 1444 + expect(html.includes('request_uri')).toBeTruthy(); // Should include request_uri in form 1503 1445 }); 1504 1446 1505 1447 it('completes full direct authorization flow', async () => { ··· 1525 1467 authorizeUrl.searchParams.set('login_hint', DID); 1526 1468 1527 1469 const getRes = await fetch(authorizeUrl.toString()); 1528 - assert.strictEqual(getRes.status, 200); 1470 + expect(getRes.status).toBe(200); 1529 1471 const html = await getRes.text(); 1530 1472 1531 1473 // Extract request_uri from the form 1532 1474 const requestUriMatch = html.match(/name="request_uri" value="([^"]+)"/); 1533 - assert.ok(requestUriMatch, 'Should have request_uri in form'); 1475 + expect(requestUriMatch).toBeTruthy(); 1534 1476 const requestUri = requestUriMatch[1]; 1535 1477 1536 1478 // Step 2: POST to authorize (user approval) ··· 1545 1487 redirect: 'manual', 1546 1488 }); 1547 1489 1548 - assert.strictEqual(authRes.status, 302, 'Should redirect after approval'); 1490 + expect(authRes.status).toBe(302); 1549 1491 const location = authRes.headers.get('location'); 1550 - assert.ok(location, 'Should have Location header'); 1492 + expect(location).toBeTruthy(); 1551 1493 const locationUrl = new URL(location); 1552 1494 const code = locationUrl.searchParams.get('code'); 1553 - assert.ok(code, 'Should have authorization code'); 1554 - assert.strictEqual(locationUrl.searchParams.get('state'), state); 1495 + expect(code).toBeTruthy(); 1496 + expect(locationUrl.searchParams.get('state')).toBe(state); 1555 1497 1556 1498 // Step 3: Exchange code for tokens 1557 1499 const dpop = await DpopClient.create(); ··· 1572 1514 }).toString(), 1573 1515 }); 1574 1516 1575 - assert.strictEqual(tokenRes.status, 200, 'Token exchange should succeed'); 1517 + expect(tokenRes.status).toBe(200); 1576 1518 const tokenData = await tokenRes.json(); 1577 - assert.ok(tokenData.access_token, 'Should have access_token'); 1578 - assert.strictEqual(tokenData.token_type, 'DPoP'); 1519 + expect(tokenData.access_token).toBeTruthy(); 1520 + expect(tokenData.token_type).toBe('DPoP'); 1579 1521 }); 1580 1522 1581 1523 it('consent page shows profile card when login_hint is provided', async () => { ··· 1601 1543 const res = await fetch(authorizeUrl.toString()); 1602 1544 const html = await res.text(); 1603 1545 1604 - assert.ok( 1605 - html.includes('profile-card'), 1606 - 'Should include profile card element', 1607 - ); 1608 - assert.ok( 1609 - html.includes('@test.handle.example'), 1610 - 'Should show handle with @ prefix', 1611 - ); 1612 - assert.ok( 1613 - html.includes('app.bsky.actor.getProfile'), 1614 - 'Should include profile fetch script', 1615 - ); 1546 + expect(html.includes('profile-card')).toBeTruthy(); // Should include profile card element 1547 + expect(html.includes('@test.handle.example')).toBeTruthy(); // Should show handle with @ prefix 1548 + expect(html.includes('app.bsky.actor.getProfile')).toBeTruthy(); // Should include profile fetch script 1616 1549 }); 1617 1550 1618 1551 it('consent page does not show profile card when login_hint is omitted', async () => { ··· 1639 1572 const html = await res.text(); 1640 1573 1641 1574 // Check for the actual element (id="profile-card"), not the CSS class selector 1642 - assert.ok( 1643 - !html.includes('id="profile-card"'), 1644 - 'Should NOT include profile card element', 1645 - ); 1646 - assert.ok( 1647 - !html.includes('app.bsky.actor.getProfile'), 1648 - 'Should NOT include profile fetch script', 1649 - ); 1575 + expect(!html.includes('id="profile-card"')).toBeTruthy(); // Should NOT include profile card element 1576 + expect(!html.includes('app.bsky.actor.getProfile')).toBeTruthy(); // Should NOT include profile fetch script 1650 1577 }); 1651 1578 1652 1579 it('consent page escapes dangerous characters in login_hint', async () => { ··· 1677 1604 1678 1605 // JSON.stringify escapes double quotes, so the payload should be escaped 1679 1606 // The raw ");alert(" should NOT appear - it should be escaped as \");alert(\" 1680 - assert.ok( 1681 - !html.includes('");alert("'), 1607 + expect( 1608 + !html.includes('").toBeTruthy();alert("'), 1682 1609 'Should escape double quotes to prevent XSS breakout', 1683 1610 ); 1684 1611 // Verify the escaped version is present (backslash before the quote) 1685 - assert.ok( 1686 - html.includes('\\"'), 1687 - 'Should contain escaped characters from JSON.stringify', 1688 - ); 1612 + expect(html.includes('\\"')).toBeTruthy(); // Should contain escaped characters from JSON.stringify 1689 1613 }); 1690 1614 }); 1691 1615 ··· 1703 1627 }, 1704 1628 ); 1705 1629 // AppView returns 200 (found) or 400 (RecordNotFound), not 404 or 502 1706 - assert.ok( 1630 + expect( 1707 1631 res.status === 200 || res.status === 400, 1708 1632 `Expected 200 or 400 from AppView, got ${res.status}`, 1709 - ); 1633 + ).toBeTruthy(); 1710 1634 // Verify we got a JSON response (not an error page) 1711 1635 const contentType = res.headers.get('content-type'); 1712 - assert.ok( 1713 - contentType?.includes('application/json'), 1714 - 'Should return JSON', 1715 - ); 1636 + expect(contentType?.includes('application/json')).toBeTruthy(); // Should return JSON 1716 1637 }); 1717 1638 1718 1639 it('handles foreign repo locally without header (returns not found)', async () => { ··· 1722 1643 `${BASE}/xrpc/com.atproto.repo.getRecord?repo=did:plc:z72i7hdynmk6r22z27h6tvur&collection=app.bsky.feed.post&rkey=3juzlwllznd24`, 1723 1644 ); 1724 1645 // Local PDS returns 404 for non-existent record/DID 1725 - assert.strictEqual(res.status, 404); 1646 + expect(res.status).toBe(404); 1726 1647 }); 1727 1648 1728 1649 it('returns error for unknown proxy service', async () => { ··· 1734 1655 }, 1735 1656 }, 1736 1657 ); 1737 - assert.strictEqual(res.status, 400); 1658 + expect(res.status).toBe(400); 1738 1659 const data = await res.json(); 1739 - assert.ok(data.message.includes('Unknown proxy service')); 1660 + expect(data.message.includes('Unknown proxy service')).toBeTruthy();; 1740 1661 }); 1741 1662 1742 1663 it('returns error for malformed atproto-proxy header', async () => { ··· 1749 1670 }, 1750 1671 }, 1751 1672 ); 1752 - assert.strictEqual(res1.status, 400); 1673 + expect(res1.status).toBe(400); 1753 1674 const data1 = await res1.json(); 1754 - assert.ok(data1.message.includes('Malformed atproto-proxy header')); 1675 + expect(data1.message.includes('Malformed atproto-proxy header')).toBeTruthy();; 1755 1676 1756 1677 // Header with only fragment 1757 1678 const res2 = await fetch( ··· 1762 1683 }, 1763 1684 }, 1764 1685 ); 1765 - assert.strictEqual(res2.status, 400); 1686 + expect(res2.status).toBe(400); 1766 1687 const data2 = await res2.json(); 1767 - assert.ok(data2.message.includes('Malformed atproto-proxy header')); 1688 + expect(data2.message.includes('Malformed atproto-proxy header')).toBeTruthy();; 1768 1689 }); 1769 1690 1770 1691 it('returns local record for local DID without proxy header', async () => { ··· 1788 1709 const res = await fetch( 1789 1710 `${BASE}/xrpc/com.atproto.repo.getRecord?repo=${DID}&collection=app.bsky.feed.post&rkey=${rkey}`, 1790 1711 ); 1791 - assert.strictEqual(res.status, 200); 1712 + expect(res.status).toBe(200); 1792 1713 const data = await res.json(); 1793 - assert.ok(data.value.text.includes('Test post for local DID test')); 1714 + expect(data.value.text.includes('Test post for local DID test')).toBeTruthy();; 1794 1715 1795 1716 // Cleanup - verify success to ensure test isolation 1796 1717 const { status: cleanupStatus } = await jsonPost( ··· 1798 1719 { repo: DID, collection: 'app.bsky.feed.post', rkey }, 1799 1720 { Authorization: `Bearer ${token}` }, 1800 1721 ); 1801 - assert.strictEqual(cleanupStatus, 200, 'Cleanup should succeed'); 1722 + expect(cleanupStatus).toBe(200); 1802 1723 }); 1803 1724 1804 1725 it('describeRepo handles foreign DID locally', async () => { ··· 1807 1728 `${BASE}/xrpc/com.atproto.repo.describeRepo?repo=did:plc:z72i7hdynmk6r22z27h6tvur`, 1808 1729 ); 1809 1730 // Local PDS returns 404 for non-existent DID 1810 - assert.strictEqual(res.status, 404); 1731 + expect(res.status).toBe(404); 1811 1732 }); 1812 1733 1813 1734 it('listRecords handles foreign DID locally', async () => { ··· 1817 1738 `${BASE}/xrpc/com.atproto.repo.listRecords?repo=did:plc:z72i7hdynmk6r22z27h6tvur&collection=app.bsky.feed.post&limit=1`, 1818 1739 ); 1819 1740 // Local PDS returns 200 with empty records (or 404 for completely unknown DID) 1820 - assert.ok( 1741 + expect( 1821 1742 res.status === 200 || res.status === 404, 1822 1743 `Expected 200 or 404, got ${res.status}`, 1823 - ); 1744 + ).toBeTruthy(); 1824 1745 }); 1825 1746 }); 1826 1747 ··· 1831 1752 { repo: DID, collection: 'app.bsky.feed.post', rkey: testRkey }, 1832 1753 { Authorization: `Bearer ${token}` }, 1833 1754 ); 1834 - assert.strictEqual(status, 200); 1755 + expect(status).toBe(200); 1835 1756 }); 1836 1757 }); 1837 1758 });
+239 -300
test/pds.test.js
··· 1 - import assert from 'node:assert'; 2 - import { describe, test } from 'node:test'; 1 + import { describe, test, expect } from 'vitest'; 3 2 import { 4 3 base32Decode, 5 4 base32Encode, ··· 49 48 0xa2, 0x65, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x65, 0x77, 0x6f, 0x72, 0x6c, 50 49 0x64, 0x63, 0x6e, 0x75, 0x6d, 0x18, 0x2a, 51 50 ]); 52 - assert.deepStrictEqual(encoded, expected); 51 + expect(encoded).toEqual(expected); 53 52 }); 54 53 55 54 test('encodes null', () => { 56 55 const encoded = cborEncode(null); 57 - assert.deepStrictEqual(encoded, new Uint8Array([0xf6])); 56 + expect(encoded).toEqual(new Uint8Array([0xf6])); 58 57 }); 59 58 60 59 test('encodes booleans', () => { 61 - assert.deepStrictEqual(cborEncode(true), new Uint8Array([0xf5])); 62 - assert.deepStrictEqual(cborEncode(false), new Uint8Array([0xf4])); 60 + expect(cborEncode(true)).toEqual(new Uint8Array([0xf5])); 61 + expect(cborEncode(false)).toEqual(new Uint8Array([0xf4])); 63 62 }); 64 63 65 64 test('encodes small integers', () => { 66 - assert.deepStrictEqual(cborEncode(0), new Uint8Array([0x00])); 67 - assert.deepStrictEqual(cborEncode(1), new Uint8Array([0x01])); 68 - assert.deepStrictEqual(cborEncode(23), new Uint8Array([0x17])); 65 + expect(cborEncode(0)).toEqual(new Uint8Array([0x00])); 66 + expect(cborEncode(1)).toEqual(new Uint8Array([0x01])); 67 + expect(cborEncode(23)).toEqual(new Uint8Array([0x17])); 69 68 }); 70 69 71 70 test('encodes integers >= 24', () => { 72 - assert.deepStrictEqual(cborEncode(24), new Uint8Array([0x18, 0x18])); 73 - assert.deepStrictEqual(cborEncode(255), new Uint8Array([0x18, 0xff])); 71 + expect(cborEncode(24)).toEqual(new Uint8Array([0x18, 0x18])); 72 + expect(cborEncode(255)).toEqual(new Uint8Array([0x18, 0xff])); 74 73 }); 75 74 76 75 test('encodes negative integers', () => { 77 - assert.deepStrictEqual(cborEncode(-1), new Uint8Array([0x20])); 78 - assert.deepStrictEqual(cborEncode(-10), new Uint8Array([0x29])); 76 + expect(cborEncode(-1)).toEqual(new Uint8Array([0x20])); 77 + expect(cborEncode(-10)).toEqual(new Uint8Array([0x29])); 79 78 }); 80 79 81 80 test('encodes strings', () => { 82 81 const encoded = cborEncode('hello'); 83 82 // 0x65 = text string of length 5 84 - assert.deepStrictEqual( 85 - encoded, 86 - new Uint8Array([0x65, 0x68, 0x65, 0x6c, 0x6c, 0x6f]), 87 - ); 83 + expect(encoded).toEqual(new Uint8Array([0x65, 0x68, 0x65, 0x6c, 0x6c, 0x6f])); 88 84 }); 89 85 90 86 test('encodes byte strings', () => { 91 87 const bytes = new Uint8Array([1, 2, 3]); 92 88 const encoded = cborEncode(bytes); 93 89 // 0x43 = byte string of length 3 94 - assert.deepStrictEqual(encoded, new Uint8Array([0x43, 1, 2, 3])); 90 + expect(encoded).toEqual(new Uint8Array([0x43, 1, 2, 3])); 95 91 }); 96 92 97 93 test('encodes arrays', () => { 98 94 const encoded = cborEncode([1, 2, 3]); 99 95 // 0x83 = array of length 3 100 - assert.deepStrictEqual(encoded, new Uint8Array([0x83, 0x01, 0x02, 0x03])); 96 + expect(encoded).toEqual(new Uint8Array([0x83, 0x01, 0x02, 0x03])); 101 97 }); 102 98 103 99 test('sorts map keys deterministically', () => { 104 100 const encoded1 = cborEncode({ z: 1, a: 2 }); 105 101 const encoded2 = cborEncode({ a: 2, z: 1 }); 106 - assert.deepStrictEqual(encoded1, encoded2); 102 + expect(encoded1).toEqual(encoded2); 107 103 // First key should be 'a' (0x61) 108 - assert.strictEqual(encoded1[1], 0x61); 104 + expect(encoded1[1]).toBe(0x61); 109 105 }); 110 106 111 107 test('encodes large integers >= 2^31 without overflow', () => { ··· 113 109 const twoTo31 = 2147483648; 114 110 const encoded = cborEncode(twoTo31); 115 111 const decoded = cborDecode(encoded); 116 - assert.strictEqual(decoded, twoTo31); 112 + expect(decoded).toBe(twoTo31); 117 113 118 114 // 2^32 - 1 (max unsigned 32-bit) 119 115 const maxU32 = 4294967295; 120 116 const encoded2 = cborEncode(maxU32); 121 117 const decoded2 = cborDecode(encoded2); 122 - assert.strictEqual(decoded2, maxU32); 118 + expect(decoded2).toBe(maxU32); 123 119 }); 124 120 125 121 test('encodes 2^31 with correct byte format', () => { 126 122 // 2147483648 = 0x80000000 127 123 // CBOR: major type 0 (unsigned int), additional info 26 (4-byte follows) 128 124 const encoded = cborEncode(2147483648); 129 - assert.strictEqual(encoded[0], 0x1a); // type 0 | info 26 130 - assert.strictEqual(encoded[1], 0x80); 131 - assert.strictEqual(encoded[2], 0x00); 132 - assert.strictEqual(encoded[3], 0x00); 133 - assert.strictEqual(encoded[4], 0x00); 125 + expect(encoded[0]).toBe(0x1a); // type 0 | info 26 126 + expect(encoded[1]).toBe(0x80); 127 + expect(encoded[2]).toBe(0x00); 128 + expect(encoded[3]).toBe(0x00); 129 + expect(encoded[4]).toBe(0x00); 134 130 }); 135 131 }); 136 132 ··· 138 134 test('encodes bytes to base32lower', () => { 139 135 const bytes = new Uint8Array([0x01, 0x71, 0x12, 0x20]); 140 136 const encoded = base32Encode(bytes); 141 - assert.strictEqual(typeof encoded, 'string'); 142 - assert.match(encoded, /^[a-z2-7]+$/); 137 + expect(typeof encoded).toBe('string'); 138 + expect(encoded).toMatch(/^[a-z2-7]+$/); 143 139 }); 144 140 }); 145 141 ··· 148 144 const data = cborEncode({ test: 'data' }); 149 145 const cid = await createCid(data); 150 146 151 - assert.strictEqual(cid.length, 36); // 2 prefix + 2 multihash header + 32 hash 152 - assert.strictEqual(cid[0], 0x01); // CIDv1 153 - assert.strictEqual(cid[1], 0x71); // dag-cbor 154 - assert.strictEqual(cid[2], 0x12); // sha-256 155 - assert.strictEqual(cid[3], 0x20); // 32 bytes 147 + expect(cid.length).toBe(36); // 2 prefix + 2 multihash header + 32 hash 148 + expect(cid[0]).toBe(0x01); // CIDv1 149 + expect(cid[1]).toBe(0x71); // dag-cbor 150 + expect(cid[2]).toBe(0x12); // sha-256 151 + expect(cid[3]).toBe(0x20); // 32 bytes 156 152 }); 157 153 158 154 test('createBlobCid uses raw codec', async () => { 159 155 const data = new Uint8Array([0xff, 0xd8, 0xff, 0xe0]); // JPEG magic bytes 160 156 const cid = await createBlobCid(data); 161 157 162 - assert.strictEqual(cid.length, 36); 163 - assert.strictEqual(cid[0], 0x01); // CIDv1 164 - assert.strictEqual(cid[1], 0x55); // raw codec 165 - assert.strictEqual(cid[2], 0x12); // sha-256 166 - assert.strictEqual(cid[3], 0x20); // 32 bytes 158 + expect(cid.length).toBe(36); 159 + expect(cid[0]).toBe(0x01); // CIDv1 160 + expect(cid[1]).toBe(0x55); // raw codec 161 + expect(cid[2]).toBe(0x12); // sha-256 162 + expect(cid[3]).toBe(0x20); // 32 bytes 167 163 }); 168 164 169 165 test('same bytes produce different CIDs with different codecs', async () => { ··· 171 167 const dagCborCid = cidToString(await createCid(data)); 172 168 const rawCid = cidToString(await createBlobCid(data)); 173 169 174 - assert.notStrictEqual(dagCborCid, rawCid); 170 + expect(dagCborCid).not.toBe(rawCid); 175 171 }); 176 172 177 173 test('cidToString returns base32lower with b prefix', async () => { ··· 179 175 const cid = await createCid(data); 180 176 const cidStr = cidToString(cid); 181 177 182 - assert.strictEqual(cidStr[0], 'b'); 183 - assert.match(cidStr, /^b[a-z2-7]+$/); 178 + expect(cidStr[0]).toBe('b'); 179 + expect(cidStr).toMatch(/^b[a-z2-7]+$/); 184 180 }); 185 181 186 182 test('same input produces same CID', async () => { ··· 189 185 const cid1 = cidToString(await createCid(data1)); 190 186 const cid2 = cidToString(await createCid(data2)); 191 187 192 - assert.strictEqual(cid1, cid2); 188 + expect(cid1).toBe(cid2); 193 189 }); 194 190 195 191 test('different input produces different CID', async () => { 196 192 const cid1 = cidToString(await createCid(cborEncode({ a: 1 }))); 197 193 const cid2 = cidToString(await createCid(cborEncode({ a: 2 }))); 198 194 199 - assert.notStrictEqual(cid1, cid2); 195 + expect(cid1).not.toBe(cid2); 200 196 }); 201 197 }); 202 198 203 199 describe('TID Generation', () => { 204 200 test('creates 13-character TIDs', () => { 205 201 const tid = createTid(); 206 - assert.strictEqual(tid.length, 13); 202 + expect(tid.length).toBe(13); 207 203 }); 208 204 209 205 test('uses valid base32-sort characters', () => { 210 206 const tid = createTid(); 211 - assert.match(tid, /^[234567abcdefghijklmnopqrstuvwxyz]+$/); 207 + expect(tid).toMatch(/^[234567abcdefghijklmnopqrstuvwxyz]+$/); 212 208 }); 213 209 214 210 test('generates monotonically increasing TIDs', () => { ··· 216 212 const tid2 = createTid(); 217 213 const tid3 = createTid(); 218 214 219 - assert.ok(tid1 < tid2, `${tid1} should be less than ${tid2}`); 220 - assert.ok(tid2 < tid3, `${tid2} should be less than ${tid3}`); 215 + expect(tid1 < tid2).toBe(true); 216 + expect(tid2 < tid3).toBe(true); 221 217 }); 222 218 223 219 test('generates unique TIDs', () => { ··· 225 221 for (let i = 0; i < 100; i++) { 226 222 tids.add(createTid()); 227 223 } 228 - assert.strictEqual(tids.size, 100); 224 + expect(tids.size).toBe(100); 229 225 }); 230 226 }); 231 227 ··· 233 229 test('generates key pair with correct sizes', async () => { 234 230 const kp = await generateKeyPair(); 235 231 236 - assert.strictEqual(kp.privateKey.length, 32); 237 - assert.strictEqual(kp.publicKey.length, 33); // compressed 238 - assert.ok(kp.publicKey[0] === 0x02 || kp.publicKey[0] === 0x03); 232 + expect(kp.privateKey.length).toBe(32); 233 + expect(kp.publicKey.length).toBe(33); // compressed 234 + expect(kp.publicKey[0] === 0x02 || kp.publicKey[0] === 0x03).toBe(true); 239 235 }); 240 236 241 237 test('can sign data with generated key', async () => { ··· 244 240 const data = new TextEncoder().encode('test message'); 245 241 const sig = await sign(key, data); 246 242 247 - assert.strictEqual(sig.length, 64); // r (32) + s (32) 243 + expect(sig.length).toBe(64); // r (32) + s (32) 248 244 }); 249 245 250 246 test('different messages produce different signatures', async () => { ··· 254 250 const sig1 = await sign(key, new TextEncoder().encode('message 1')); 255 251 const sig2 = await sign(key, new TextEncoder().encode('message 2')); 256 252 257 - assert.notDeepStrictEqual(sig1, sig2); 253 + expect(sig1).not.toEqual(sig2); 258 254 }); 259 255 260 256 test('bytesToHex and hexToBytes roundtrip', () => { ··· 262 258 const hex = bytesToHex(original); 263 259 const back = hexToBytes(hex); 264 260 265 - assert.strictEqual(hex, '000ff0ffabcd'); 266 - assert.deepStrictEqual(back, original); 261 + expect(hex).toBe('000ff0ffabcd'); 262 + expect(back).toEqual(original); 267 263 }); 268 264 269 265 test('importPrivateKey rejects invalid key lengths', async () => { 270 266 // Too short 271 - await assert.rejects( 272 - () => importPrivateKey(new Uint8Array(31)), 267 + await expect(() => importPrivateKey(new Uint8Array(31))).rejects.toThrow( 273 268 /expected 32 bytes, got 31/, 274 269 ); 275 270 276 271 // Too long 277 - await assert.rejects( 278 - () => importPrivateKey(new Uint8Array(33)), 272 + await expect(() => importPrivateKey(new Uint8Array(33))).rejects.toThrow( 279 273 /expected 32 bytes, got 33/, 280 274 ); 281 275 282 276 // Empty 283 - await assert.rejects( 284 - () => importPrivateKey(new Uint8Array(0)), 277 + await expect(() => importPrivateKey(new Uint8Array(0))).rejects.toThrow( 285 278 /expected 32 bytes, got 0/, 286 279 ); 287 280 }); 288 281 289 282 test('importPrivateKey rejects non-Uint8Array input', async () => { 290 283 // Arrays have .length but aren't Uint8Array 291 - await assert.rejects( 292 - () => importPrivateKey([1, 2, 3]), 284 + await expect(() => importPrivateKey([1, 2, 3])).rejects.toThrow( 293 285 /Invalid private key/, 294 286 ); 295 287 296 288 // Strings don't work either 297 - await assert.rejects( 298 - () => importPrivateKey('not bytes'), 289 + await expect(() => importPrivateKey('not bytes')).rejects.toThrow( 299 290 /Invalid private key/, 300 291 ); 301 292 302 293 // null/undefined 303 - await assert.rejects(() => importPrivateKey(null), /Invalid private key/); 294 + await expect(() => importPrivateKey(null)).rejects.toThrow(/Invalid private key/); 304 295 }); 305 296 }); 306 297 307 298 describe('MST Key Depth', () => { 308 299 test('returns a non-negative integer', async () => { 309 300 const depth = await getKeyDepth('app.bsky.feed.post/abc123'); 310 - assert.strictEqual(typeof depth, 'number'); 311 - assert.ok(depth >= 0); 301 + expect(typeof depth).toBe('number'); 302 + expect(depth >= 0).toBe(true); 312 303 }); 313 304 314 305 test('is deterministic for same key', async () => { 315 306 const key = 'app.bsky.feed.post/test123'; 316 307 const depth1 = await getKeyDepth(key); 317 308 const depth2 = await getKeyDepth(key); 318 - assert.strictEqual(depth1, depth2); 309 + expect(depth1).toBe(depth2); 319 310 }); 320 311 321 312 test('different keys can have different depths', async () => { ··· 325 316 depths.add(await getKeyDepth(`collection/key${i}`)); 326 317 } 327 318 // Should have at least 1 unique depth (realistically more) 328 - assert.ok(depths.size >= 1); 319 + expect(depths.size >= 1).toBe(true); 329 320 }); 330 321 331 322 test('handles empty string', async () => { 332 323 const depth = await getKeyDepth(''); 333 - assert.strictEqual(typeof depth, 'number'); 334 - assert.ok(depth >= 0); 324 + expect(typeof depth).toBe('number'); 325 + expect(depth >= 0).toBe(true); 335 326 }); 336 327 337 328 test('handles unicode strings', async () => { 338 329 const depth = await getKeyDepth('app.bsky.feed.post/émoji🎉'); 339 - assert.strictEqual(typeof depth, 'number'); 340 - assert.ok(depth >= 0); 330 + expect(typeof depth).toBe('number'); 331 + expect(depth >= 0).toBe(true); 341 332 }); 342 333 }); 343 334 ··· 346 337 const original = { hello: 'world', num: 42 }; 347 338 const encoded = cborEncode(original); 348 339 const decoded = cborDecode(encoded); 349 - assert.deepStrictEqual(decoded, original); 340 + expect(decoded).toEqual(original); 350 341 }); 351 342 352 343 test('decodes null', () => { 353 344 const encoded = cborEncode(null); 354 345 const decoded = cborDecode(encoded); 355 - assert.strictEqual(decoded, null); 346 + expect(decoded).toBe(null); 356 347 }); 357 348 358 349 test('decodes booleans', () => { 359 - assert.strictEqual(cborDecode(cborEncode(true)), true); 360 - assert.strictEqual(cborDecode(cborEncode(false)), false); 350 + expect(cborDecode(cborEncode(true))).toBe(true); 351 + expect(cborDecode(cborEncode(false))).toBe(false); 361 352 }); 362 353 363 354 test('decodes integers', () => { 364 - assert.strictEqual(cborDecode(cborEncode(0)), 0); 365 - assert.strictEqual(cborDecode(cborEncode(42)), 42); 366 - assert.strictEqual(cborDecode(cborEncode(255)), 255); 367 - assert.strictEqual(cborDecode(cborEncode(-1)), -1); 368 - assert.strictEqual(cborDecode(cborEncode(-10)), -10); 355 + expect(cborDecode(cborEncode(0))).toBe(0); 356 + expect(cborDecode(cborEncode(42))).toBe(42); 357 + expect(cborDecode(cborEncode(255))).toBe(255); 358 + expect(cborDecode(cborEncode(-1))).toBe(-1); 359 + expect(cborDecode(cborEncode(-10))).toBe(-10); 369 360 }); 370 361 371 362 test('decodes strings', () => { 372 - assert.strictEqual(cborDecode(cborEncode('hello')), 'hello'); 373 - assert.strictEqual(cborDecode(cborEncode('')), ''); 363 + expect(cborDecode(cborEncode('hello'))).toBe('hello'); 364 + expect(cborDecode(cborEncode(''))).toBe(''); 374 365 }); 375 366 376 367 test('decodes arrays', () => { 377 - assert.deepStrictEqual(cborDecode(cborEncode([1, 2, 3])), [1, 2, 3]); 378 - assert.deepStrictEqual(cborDecode(cborEncode([])), []); 368 + expect(cborDecode(cborEncode([1, 2, 3]))).toEqual([1, 2, 3]); 369 + expect(cborDecode(cborEncode([]))).toEqual([]); 379 370 }); 380 371 381 372 test('decodes nested structures', () => { 382 373 const original = { arr: [1, { nested: true }], str: 'test' }; 383 374 const decoded = cborDecode(cborEncode(original)); 384 - assert.deepStrictEqual(decoded, original); 375 + expect(decoded).toEqual(original); 385 376 }); 386 377 }); 387 378 388 379 describe('CAR File Builder', () => { 389 380 test('varint encodes small numbers', () => { 390 - assert.deepStrictEqual(varint(0), new Uint8Array([0])); 391 - assert.deepStrictEqual(varint(1), new Uint8Array([1])); 392 - assert.deepStrictEqual(varint(127), new Uint8Array([127])); 381 + expect(varint(0)).toEqual(new Uint8Array([0])); 382 + expect(varint(1)).toEqual(new Uint8Array([1])); 383 + expect(varint(127)).toEqual(new Uint8Array([127])); 393 384 }); 394 385 395 386 test('varint encodes multi-byte numbers', () => { 396 387 // 128 = 0x80 -> [0x80 | 0x00, 0x01] = [0x80, 0x01] 397 - assert.deepStrictEqual(varint(128), new Uint8Array([0x80, 0x01])); 388 + expect(varint(128)).toEqual(new Uint8Array([0x80, 0x01])); 398 389 // 300 = 0x12c -> [0xac, 0x02] 399 - assert.deepStrictEqual(varint(300), new Uint8Array([0xac, 0x02])); 390 + expect(varint(300)).toEqual(new Uint8Array([0xac, 0x02])); 400 391 }); 401 392 402 393 test('base32 encode/decode roundtrip', () => { 403 394 const original = new Uint8Array([0x01, 0x71, 0x12, 0x20, 0xab, 0xcd]); 404 395 const encoded = base32Encode(original); 405 396 const decoded = base32Decode(encoded); 406 - assert.deepStrictEqual(decoded, original); 397 + expect(decoded).toEqual(original); 407 398 }); 408 399 409 400 test('buildCarFile produces valid structure', async () => { ··· 413 404 414 405 const car = buildCarFile(cidStr, [{ cid: cidStr, data }]); 415 406 416 - assert.ok(car instanceof Uint8Array); 417 - assert.ok(car.length > 0); 407 + expect(car instanceof Uint8Array).toBe(true); 408 + expect(car.length > 0).toBe(true); 418 409 // First byte should be varint of header length 419 - assert.ok(car[0] > 0); 410 + expect(car[0] > 0).toBe(true); 420 411 }); 421 412 }); 422 413 ··· 424 415 test('base64UrlEncode encodes bytes correctly', () => { 425 416 const input = new TextEncoder().encode('hello world'); 426 417 const encoded = base64UrlEncode(input); 427 - assert.strictEqual(encoded, 'aGVsbG8gd29ybGQ'); 428 - assert.ok(!encoded.includes('+')); 429 - assert.ok(!encoded.includes('/')); 430 - assert.ok(!encoded.includes('=')); 418 + expect(encoded).toBe('aGVsbG8gd29ybGQ'); 419 + expect(encoded.includes('+')).toBe(false); 420 + expect(encoded.includes('/')).toBe(false); 421 + expect(encoded.includes('=')).toBe(false); 431 422 }); 432 423 433 424 test('base64UrlDecode decodes string correctly', () => { 434 425 const decoded = base64UrlDecode('aGVsbG8gd29ybGQ'); 435 426 const str = new TextDecoder().decode(decoded); 436 - assert.strictEqual(str, 'hello world'); 427 + expect(str).toBe('hello world'); 437 428 }); 438 429 439 430 test('base64url roundtrip', () => { 440 431 const original = new Uint8Array([0, 1, 2, 255, 254, 253]); 441 432 const encoded = base64UrlEncode(original); 442 433 const decoded = base64UrlDecode(encoded); 443 - assert.deepStrictEqual(decoded, original); 434 + expect(decoded).toEqual(original); 444 435 }); 445 436 }); 446 437 ··· 451 442 const jwt = await createAccessJwt(did, secret); 452 443 453 444 const parts = jwt.split('.'); 454 - assert.strictEqual(parts.length, 3); 445 + expect(parts.length).toBe(3); 455 446 456 447 // Decode header 457 448 const header = JSON.parse( 458 449 new TextDecoder().decode(base64UrlDecode(parts[0])), 459 450 ); 460 - assert.strictEqual(header.typ, 'at+jwt'); 461 - assert.strictEqual(header.alg, 'HS256'); 451 + expect(header.typ).toBe('at+jwt'); 452 + expect(header.alg).toBe('HS256'); 462 453 463 454 // Decode payload 464 455 const payload = JSON.parse( 465 456 new TextDecoder().decode(base64UrlDecode(parts[1])), 466 457 ); 467 - assert.strictEqual(payload.scope, 'com.atproto.access'); 468 - assert.strictEqual(payload.sub, did); 469 - assert.strictEqual(payload.aud, did); 470 - assert.ok(payload.iat > 0); 471 - assert.ok(payload.exp > payload.iat); 458 + expect(payload.scope).toBe('com.atproto.access'); 459 + expect(payload.sub).toBe(did); 460 + expect(payload.aud).toBe(did); 461 + expect(payload.iat > 0).toBe(true); 462 + expect(payload.exp > payload.iat).toBe(true); 472 463 }); 473 464 474 465 test('createRefreshJwt creates valid JWT with jti', async () => { ··· 480 471 const header = JSON.parse( 481 472 new TextDecoder().decode(base64UrlDecode(parts[0])), 482 473 ); 483 - assert.strictEqual(header.typ, 'refresh+jwt'); 474 + expect(header.typ).toBe('refresh+jwt'); 484 475 485 476 const payload = JSON.parse( 486 477 new TextDecoder().decode(base64UrlDecode(parts[1])), 487 478 ); 488 - assert.strictEqual(payload.scope, 'com.atproto.refresh'); 489 - assert.ok(payload.jti); // has unique token ID 479 + expect(payload.scope).toBe('com.atproto.refresh'); 480 + expect(payload.jti).toBeTruthy(); // has unique token ID 490 481 }); 491 482 }); 492 483 ··· 497 488 const jwt = await createAccessJwt(did, secret); 498 489 499 490 const payload = await verifyAccessJwt(jwt, secret); 500 - assert.strictEqual(payload.sub, did); 501 - assert.strictEqual(payload.scope, 'com.atproto.access'); 491 + expect(payload.sub).toBe(did); 492 + expect(payload.scope).toBe('com.atproto.access'); 502 493 }); 503 494 504 495 test('verifyAccessJwt throws for wrong secret', async () => { 505 496 const did = 'did:web:test.example'; 506 497 const jwt = await createAccessJwt(did, 'correct-secret'); 507 498 508 - await assert.rejects( 509 - () => verifyAccessJwt(jwt, 'wrong-secret'), 499 + await expect(() => verifyAccessJwt(jwt, 'wrong-secret')).rejects.toThrow( 510 500 /invalid signature/i, 511 501 ); 512 502 }); ··· 517 507 // Create token that expired 1 second ago 518 508 const jwt = await createAccessJwt(did, secret, -1); 519 509 520 - await assert.rejects(() => verifyAccessJwt(jwt, secret), /expired/i); 510 + await expect(() => verifyAccessJwt(jwt, secret)).rejects.toThrow(/expired/i); 521 511 }); 522 512 523 513 test('verifyAccessJwt throws for refresh token', async () => { ··· 525 515 const secret = 'test-secret-key'; 526 516 const jwt = await createRefreshJwt(did, secret); 527 517 528 - await assert.rejects( 529 - () => verifyAccessJwt(jwt, secret), 518 + await expect(() => verifyAccessJwt(jwt, secret)).rejects.toThrow( 530 519 /invalid token type/i, 531 520 ); 532 521 }); ··· 537 526 const jwt = await createRefreshJwt(did, secret); 538 527 539 528 const payload = await verifyRefreshJwt(jwt, secret); 540 - assert.strictEqual(payload.sub, did); 541 - assert.strictEqual(payload.scope, 'com.atproto.refresh'); 542 - assert.ok(payload.jti); // has token ID 529 + expect(payload.sub).toBe(did); 530 + expect(payload.scope).toBe('com.atproto.refresh'); 531 + expect(payload.jti).toBeTruthy(); // has token ID 543 532 }); 544 533 545 534 test('verifyRefreshJwt throws for wrong secret', async () => { 546 535 const did = 'did:web:test.example'; 547 536 const jwt = await createRefreshJwt(did, 'correct-secret'); 548 537 549 - await assert.rejects( 550 - () => verifyRefreshJwt(jwt, 'wrong-secret'), 538 + await expect(() => verifyRefreshJwt(jwt, 'wrong-secret')).rejects.toThrow( 551 539 /invalid signature/i, 552 540 ); 553 541 }); ··· 558 546 // Create token that expired 1 second ago 559 547 const jwt = await createRefreshJwt(did, secret, -1); 560 548 561 - await assert.rejects(() => verifyRefreshJwt(jwt, secret), /expired/i); 549 + await expect(() => verifyRefreshJwt(jwt, secret)).rejects.toThrow(/expired/i); 562 550 }); 563 551 564 552 test('verifyRefreshJwt throws for access token', async () => { ··· 566 554 const secret = 'test-secret-key'; 567 555 const jwt = await createAccessJwt(did, secret); 568 556 569 - await assert.rejects( 570 - () => verifyRefreshJwt(jwt, secret), 557 + await expect(() => verifyRefreshJwt(jwt, secret)).rejects.toThrow( 571 558 /invalid token type/i, 572 559 ); 573 560 }); ··· 576 563 const secret = 'test-secret-key'; 577 564 578 565 // Not a JWT at all 579 - await assert.rejects( 580 - () => verifyAccessJwt('not-a-jwt', secret), 566 + await expect(() => verifyAccessJwt('not-a-jwt', secret)).rejects.toThrow( 581 567 /Invalid JWT format/i, 582 568 ); 583 569 584 570 // Only two parts 585 - await assert.rejects( 586 - () => verifyAccessJwt('two.parts', secret), 571 + await expect(() => verifyAccessJwt('two.parts', secret)).rejects.toThrow( 587 572 /Invalid JWT format/i, 588 573 ); 589 574 590 575 // Four parts 591 - await assert.rejects( 592 - () => verifyAccessJwt('one.two.three.four', secret), 576 + await expect(() => verifyAccessJwt('one.two.three.four', secret)).rejects.toThrow( 593 577 /Invalid JWT format/i, 594 578 ); 595 579 }); ··· 597 581 test('verifyRefreshJwt throws for malformed JWT', async () => { 598 582 const secret = 'test-secret-key'; 599 583 600 - await assert.rejects( 601 - () => verifyRefreshJwt('not-a-jwt', secret), 584 + await expect(() => verifyRefreshJwt('not-a-jwt', secret)).rejects.toThrow( 602 585 /Invalid JWT format/i, 603 586 ); 604 587 605 - await assert.rejects( 606 - () => verifyRefreshJwt('two.parts', secret), 588 + await expect(() => verifyRefreshJwt('two.parts', secret)).rejects.toThrow( 607 589 /Invalid JWT format/i, 608 590 ); 609 591 }); ··· 612 594 describe('MIME Type Sniffing', () => { 613 595 test('detects JPEG', () => { 614 596 const bytes = new Uint8Array([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10]); 615 - assert.strictEqual(sniffMimeType(bytes), 'image/jpeg'); 597 + expect(sniffMimeType(bytes)).toBe('image/jpeg'); 616 598 }); 617 599 618 600 test('detects PNG', () => { 619 601 const bytes = new Uint8Array([ 620 602 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 621 603 ]); 622 - assert.strictEqual(sniffMimeType(bytes), 'image/png'); 604 + expect(sniffMimeType(bytes)).toBe('image/png'); 623 605 }); 624 606 625 607 test('detects GIF', () => { 626 608 const bytes = new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]); 627 - assert.strictEqual(sniffMimeType(bytes), 'image/gif'); 609 + expect(sniffMimeType(bytes)).toBe('image/gif'); 628 610 }); 629 611 630 612 test('detects WebP', () => { ··· 642 624 0x42, 643 625 0x50, // WEBP 644 626 ]); 645 - assert.strictEqual(sniffMimeType(bytes), 'image/webp'); 627 + expect(sniffMimeType(bytes)).toBe('image/webp'); 646 628 }); 647 629 648 630 test('detects MP4', () => { ··· 660 642 0x6f, 661 643 0x6d, // isom brand 662 644 ]); 663 - assert.strictEqual(sniffMimeType(bytes), 'video/mp4'); 645 + expect(sniffMimeType(bytes)).toBe('video/mp4'); 664 646 }); 665 647 666 648 test('detects AVIF', () => { ··· 678 660 0x69, 679 661 0x66, // avif brand 680 662 ]); 681 - assert.strictEqual(sniffMimeType(bytes), 'image/avif'); 663 + expect(sniffMimeType(bytes)).toBe('image/avif'); 682 664 }); 683 665 684 666 test('detects HEIC', () => { ··· 696 678 0x69, 697 679 0x63, // heic brand 698 680 ]); 699 - assert.strictEqual(sniffMimeType(bytes), 'image/heic'); 681 + expect(sniffMimeType(bytes)).toBe('image/heic'); 700 682 }); 701 683 702 684 test('returns null for unknown', () => { 703 685 const bytes = new Uint8Array([0x00, 0x01, 0x02, 0x03]); 704 - assert.strictEqual(sniffMimeType(bytes), null); 686 + expect(sniffMimeType(bytes)).toBe(null); 705 687 }); 706 688 }); 707 689 ··· 726 708 }, 727 709 }; 728 710 const refs = findBlobRefs(record); 729 - assert.deepStrictEqual(refs, ['bafkreiabc123']); 711 + expect(refs).toEqual(['bafkreiabc123']); 730 712 }); 731 713 732 714 test('finds multiple blob refs', () => { ··· 751 733 ], 752 734 }; 753 735 const refs = findBlobRefs(record); 754 - assert.deepStrictEqual(refs, ['cid1', 'cid2']); 736 + expect(refs).toEqual(['cid1', 'cid2']); 755 737 }); 756 738 757 739 test('returns empty array when no blobs', () => { 758 740 const record = { text: 'Hello world', count: 42 }; 759 741 const refs = findBlobRefs(record); 760 - assert.deepStrictEqual(refs, []); 742 + expect(refs).toEqual([]); 761 743 }); 762 744 763 745 test('handles null and primitives', () => { 764 - assert.deepStrictEqual(findBlobRefs(null), []); 765 - assert.deepStrictEqual(findBlobRefs('string'), []); 766 - assert.deepStrictEqual(findBlobRefs(42), []); 746 + expect(findBlobRefs(null)).toEqual([]); 747 + expect(findBlobRefs('string')).toEqual([]); 748 + expect(findBlobRefs(42)).toEqual([]); 767 749 }); 768 750 }); 769 751 ··· 781 763 const jkt2 = await computeJwkThumbprint(jwk); 782 764 783 765 // Thumbprint must be deterministic 784 - assert.strictEqual(jkt1, jkt2); 766 + expect(jkt1).toBe(jkt2); 785 767 // Must be base64url-encoded SHA-256 (43 chars) 786 - assert.strictEqual(jkt1.length, 43); 768 + expect(jkt1.length).toBe(43); 787 769 // Must only contain base64url characters 788 - assert.match(jkt1, /^[A-Za-z0-9_-]+$/); 770 + expect(jkt1).toMatch(/^[A-Za-z0-9_-]+$/); 789 771 }); 790 772 791 773 test('produces different thumbprints for different keys', async () => { ··· 805 787 const jkt1 = await computeJwkThumbprint(jwk1); 806 788 const jkt2 = await computeJwkThumbprint(jwk2); 807 789 808 - assert.notStrictEqual(jkt1, jkt2); 790 + expect(jkt1).not.toBe(jkt2); 809 791 }); 810 792 }); 811 793 812 794 describe('Client Metadata', () => { 813 795 test('isLoopbackClient detects localhost', () => { 814 - assert.strictEqual(isLoopbackClient('http://localhost:8080'), true); 815 - assert.strictEqual(isLoopbackClient('http://127.0.0.1:3000'), true); 816 - assert.strictEqual(isLoopbackClient('https://example.com'), false); 796 + expect(isLoopbackClient('http://localhost:8080')).toBe(true); 797 + expect(isLoopbackClient('http://127.0.0.1:3000')).toBe(true); 798 + expect(isLoopbackClient('https://example.com')).toBe(false); 817 799 }); 818 800 819 801 test('getLoopbackClientMetadata returns permissive defaults', () => { 820 802 const metadata = getLoopbackClientMetadata('http://localhost:8080'); 821 - assert.strictEqual(metadata.client_id, 'http://localhost:8080'); 822 - assert.ok(metadata.grant_types.includes('authorization_code')); 823 - assert.strictEqual(metadata.dpop_bound_access_tokens, true); 803 + expect(metadata.client_id).toBe('http://localhost:8080'); 804 + expect(metadata.grant_types.includes('authorization_code')).toBe(true); 805 + expect(metadata.dpop_bound_access_tokens).toBe(true); 824 806 }); 825 807 826 808 test('validateClientMetadata rejects mismatched client_id', () => { ··· 830 812 grant_types: ['authorization_code'], 831 813 response_types: ['code'], 832 814 }; 833 - assert.throws( 834 - () => 835 - validateClientMetadata(metadata, 'https://example.com/metadata.json'), 836 - /client_id mismatch/, 837 - ); 815 + expect(() => 816 + validateClientMetadata(metadata, 'https://example.com/metadata.json'), 817 + ).toThrow(/client_id mismatch/); 838 818 }); 839 819 }); 840 820 ··· 844 824 const result = parseAtprotoProxyHeader( 845 825 'did:web:api.bsky.app#bsky_appview', 846 826 ); 847 - assert.deepStrictEqual(result, { 827 + expect(result).toEqual({ 848 828 did: 'did:web:api.bsky.app', 849 829 serviceId: 'bsky_appview', 850 830 }); ··· 854 834 const result = parseAtprotoProxyHeader( 855 835 'did:plc:z72i7hdynmk6r22z27h6tvur#atproto_labeler', 856 836 ); 857 - assert.deepStrictEqual(result, { 837 + expect(result).toEqual({ 858 838 did: 'did:plc:z72i7hdynmk6r22z27h6tvur', 859 839 serviceId: 'atproto_labeler', 860 840 }); 861 841 }); 862 842 863 843 test('returns null for null/undefined', () => { 864 - assert.strictEqual(parseAtprotoProxyHeader(null), null); 865 - assert.strictEqual(parseAtprotoProxyHeader(undefined), null); 866 - assert.strictEqual(parseAtprotoProxyHeader(''), null); 844 + expect(parseAtprotoProxyHeader(null)).toBe(null); 845 + expect(parseAtprotoProxyHeader(undefined)).toBe(null); 846 + expect(parseAtprotoProxyHeader('')).toBe(null); 867 847 }); 868 848 869 849 test('returns null for header without fragment', () => { 870 - assert.strictEqual(parseAtprotoProxyHeader('did:web:api.bsky.app'), null); 850 + expect(parseAtprotoProxyHeader('did:web:api.bsky.app')).toBe(null); 871 851 }); 872 852 873 853 test('returns null for header with only fragment', () => { 874 - assert.strictEqual(parseAtprotoProxyHeader('#bsky_appview'), null); 854 + expect(parseAtprotoProxyHeader('#bsky_appview')).toBe(null); 875 855 }); 876 856 877 857 test('returns null for header with trailing fragment', () => { 878 - assert.strictEqual( 879 - parseAtprotoProxyHeader('did:web:api.bsky.app#'), 880 - null, 881 - ); 858 + expect(parseAtprotoProxyHeader('did:web:api.bsky.app#')).toBe(null); 882 859 }); 883 860 }); 884 861 885 862 describe('getKnownServiceUrl', () => { 886 863 test('returns URL for known Bluesky AppView', () => { 887 864 const result = getKnownServiceUrl('did:web:api.bsky.app', 'bsky_appview'); 888 - assert.strictEqual(result, BSKY_APPVIEW_URL); 865 + expect(result).toBe(BSKY_APPVIEW_URL); 889 866 }); 890 867 891 868 test('returns null for unknown service DID', () => { ··· 893 870 'did:web:unknown.service', 894 871 'bsky_appview', 895 872 ); 896 - assert.strictEqual(result, null); 873 + expect(result).toBe(null); 897 874 }); 898 875 899 876 test('returns null for unknown service ID', () => { ··· 901 878 'did:web:api.bsky.app', 902 879 'unknown_service', 903 880 ); 904 - assert.strictEqual(result, null); 881 + expect(result).toBe(null); 905 882 }); 906 883 907 884 test('returns null for both unknown', () => { 908 885 const result = getKnownServiceUrl('did:web:unknown', 'unknown'); 909 - assert.strictEqual(result, null); 886 + expect(result).toBe(null); 910 887 }); 911 888 }); 912 889 }); ··· 915 892 describe('parseRepoScope', () => { 916 893 test('parses repo scope with query parameter action', () => { 917 894 const result = parseRepoScope('repo:app.bsky.feed.post?action=create'); 918 - assert.deepStrictEqual(result, { 895 + expect(result).toEqual({ 919 896 collection: 'app.bsky.feed.post', 920 897 actions: ['create'], 921 898 }); ··· 925 902 const result = parseRepoScope( 926 903 'repo:app.bsky.feed.post?action=create&action=update', 927 904 ); 928 - assert.deepStrictEqual(result, { 905 + expect(result).toEqual({ 929 906 collection: 'app.bsky.feed.post', 930 907 actions: ['create', 'update'], 931 908 }); ··· 933 910 934 911 test('parses repo scope without actions as all actions', () => { 935 912 const result = parseRepoScope('repo:app.bsky.feed.post'); 936 - assert.deepStrictEqual(result, { 913 + expect(result).toEqual({ 937 914 collection: 'app.bsky.feed.post', 938 915 actions: ['create', 'update', 'delete'], 939 916 }); ··· 941 918 942 919 test('parses wildcard collection with action', () => { 943 920 const result = parseRepoScope('repo:*?action=create'); 944 - assert.deepStrictEqual(result, { 921 + expect(result).toEqual({ 945 922 collection: '*', 946 923 actions: ['create'], 947 924 }); ··· 951 928 const result = parseRepoScope( 952 929 'repo?collection=app.bsky.feed.post&action=create', 953 930 ); 954 - assert.deepStrictEqual(result, { 931 + expect(result).toEqual({ 955 932 collection: 'app.bsky.feed.post', 956 933 actions: ['create'], 957 934 }); ··· 961 938 const result = parseRepoScope( 962 939 'repo:app.bsky.feed.post?action=create&action=create&action=update', 963 940 ); 964 - assert.deepStrictEqual(result, { 941 + expect(result).toEqual({ 965 942 collection: 'app.bsky.feed.post', 966 943 actions: ['create', 'update'], 967 944 }); 968 945 }); 969 946 970 947 test('returns null for non-repo scope', () => { 971 - assert.strictEqual(parseRepoScope('atproto'), null); 972 - assert.strictEqual(parseRepoScope('blob:image/*'), null); 973 - assert.strictEqual(parseRepoScope('transition:generic'), null); 948 + expect(parseRepoScope('atproto')).toBe(null); 949 + expect(parseRepoScope('blob:image/*')).toBe(null); 950 + expect(parseRepoScope('transition:generic')).toBe(null); 974 951 }); 975 952 976 953 test('returns null for invalid repo scope', () => { 977 - assert.strictEqual(parseRepoScope('repo:'), null); 978 - assert.strictEqual(parseRepoScope('repo?'), null); 954 + expect(parseRepoScope('repo:')).toBe(null); 955 + expect(parseRepoScope('repo?')).toBe(null); 979 956 }); 980 957 }); 981 958 982 959 describe('parseBlobScope', () => { 983 960 test('parses wildcard MIME', () => { 984 961 const result = parseBlobScope('blob:*/*'); 985 - assert.deepStrictEqual(result, { accept: ['*/*'] }); 962 + expect(result).toEqual({ accept: ['*/*'] }); 986 963 }); 987 964 988 965 test('parses type wildcard', () => { 989 966 const result = parseBlobScope('blob:image/*'); 990 - assert.deepStrictEqual(result, { accept: ['image/*'] }); 967 + expect(result).toEqual({ accept: ['image/*'] }); 991 968 }); 992 969 993 970 test('parses specific MIME', () => { 994 971 const result = parseBlobScope('blob:image/png'); 995 - assert.deepStrictEqual(result, { accept: ['image/png'] }); 972 + expect(result).toEqual({ accept: ['image/png'] }); 996 973 }); 997 974 998 975 test('parses multiple MIMEs', () => { 999 976 const result = parseBlobScope('blob:image/png,image/jpeg'); 1000 - assert.deepStrictEqual(result, { accept: ['image/png', 'image/jpeg'] }); 977 + expect(result).toEqual({ accept: ['image/png', 'image/jpeg'] }); 1001 978 }); 1002 979 1003 980 test('returns null for non-blob scope', () => { 1004 - assert.strictEqual(parseBlobScope('atproto'), null); 1005 - assert.strictEqual(parseBlobScope('repo:*:create'), null); 981 + expect(parseBlobScope('atproto')).toBe(null); 982 + expect(parseBlobScope('repo:*:create')).toBe(null); 1006 983 }); 1007 984 }); 1008 985 1009 986 describe('matchesMime', () => { 1010 987 test('wildcard matches everything', () => { 1011 - assert.strictEqual(matchesMime('*/*', 'image/png'), true); 1012 - assert.strictEqual(matchesMime('*/*', 'video/mp4'), true); 988 + expect(matchesMime('*/*', 'image/png')).toBe(true); 989 + expect(matchesMime('*/*', 'video/mp4')).toBe(true); 1013 990 }); 1014 991 1015 992 test('type wildcard matches same type', () => { 1016 - assert.strictEqual(matchesMime('image/*', 'image/png'), true); 1017 - assert.strictEqual(matchesMime('image/*', 'image/jpeg'), true); 1018 - assert.strictEqual(matchesMime('image/*', 'video/mp4'), false); 993 + expect(matchesMime('image/*', 'image/png')).toBe(true); 994 + expect(matchesMime('image/*', 'image/jpeg')).toBe(true); 995 + expect(matchesMime('image/*', 'video/mp4')).toBe(false); 1019 996 }); 1020 997 1021 998 test('exact match', () => { 1022 - assert.strictEqual(matchesMime('image/png', 'image/png'), true); 1023 - assert.strictEqual(matchesMime('image/png', 'image/jpeg'), false); 999 + expect(matchesMime('image/png', 'image/png')).toBe(true); 1000 + expect(matchesMime('image/png', 'image/jpeg')).toBe(false); 1024 1001 }); 1025 1002 1026 1003 test('case insensitive', () => { 1027 - assert.strictEqual(matchesMime('image/PNG', 'image/png'), true); 1028 - assert.strictEqual(matchesMime('IMAGE/*', 'image/png'), true); 1004 + expect(matchesMime('image/PNG', 'image/png')).toBe(true); 1005 + expect(matchesMime('IMAGE/*', 'image/png')).toBe(true); 1029 1006 }); 1030 1007 }); 1031 1008 }); ··· 1034 1011 describe('static scopes', () => { 1035 1012 test('atproto grants full access', () => { 1036 1013 const perms = new ScopePermissions('atproto'); 1037 - assert.strictEqual( 1038 - perms.allowsRepo('app.bsky.feed.post', 'create'), 1039 - true, 1040 - ); 1041 - assert.strictEqual(perms.allowsRepo('any.collection', 'delete'), true); 1042 - assert.strictEqual(perms.allowsBlob('image/png'), true); 1043 - assert.strictEqual(perms.allowsBlob('video/mp4'), true); 1014 + expect(perms.allowsRepo('app.bsky.feed.post', 'create')).toBe(true); 1015 + expect(perms.allowsRepo('any.collection', 'delete')).toBe(true); 1016 + expect(perms.allowsBlob('image/png')).toBe(true); 1017 + expect(perms.allowsBlob('video/mp4')).toBe(true); 1044 1018 }); 1045 1019 1046 1020 test('transition:generic grants full repo/blob access', () => { 1047 1021 const perms = new ScopePermissions('transition:generic'); 1048 - assert.strictEqual( 1049 - perms.allowsRepo('app.bsky.feed.post', 'create'), 1050 - true, 1051 - ); 1052 - assert.strictEqual(perms.allowsRepo('any.collection', 'delete'), true); 1053 - assert.strictEqual(perms.allowsBlob('image/png'), true); 1022 + expect(perms.allowsRepo('app.bsky.feed.post', 'create')).toBe(true); 1023 + expect(perms.allowsRepo('any.collection', 'delete')).toBe(true); 1024 + expect(perms.allowsBlob('image/png')).toBe(true); 1054 1025 }); 1055 1026 }); 1056 1027 1057 1028 describe('repo scopes', () => { 1058 1029 test('wildcard collection allows any collection', () => { 1059 1030 const perms = new ScopePermissions('repo:*?action=create'); 1060 - assert.strictEqual( 1061 - perms.allowsRepo('app.bsky.feed.post', 'create'), 1062 - true, 1063 - ); 1064 - assert.strictEqual( 1065 - perms.allowsRepo('app.bsky.feed.like', 'create'), 1066 - true, 1067 - ); 1068 - assert.strictEqual( 1069 - perms.allowsRepo('app.bsky.feed.post', 'delete'), 1070 - false, 1071 - ); 1031 + expect(perms.allowsRepo('app.bsky.feed.post', 'create')).toBe(true); 1032 + expect(perms.allowsRepo('app.bsky.feed.like', 'create')).toBe(true); 1033 + expect(perms.allowsRepo('app.bsky.feed.post', 'delete')).toBe(false); 1072 1034 }); 1073 1035 1074 1036 test('specific collection restricts to that collection', () => { 1075 1037 const perms = new ScopePermissions( 1076 1038 'repo:app.bsky.feed.post?action=create', 1077 1039 ); 1078 - assert.strictEqual( 1079 - perms.allowsRepo('app.bsky.feed.post', 'create'), 1080 - true, 1081 - ); 1082 - assert.strictEqual( 1083 - perms.allowsRepo('app.bsky.feed.like', 'create'), 1084 - false, 1085 - ); 1040 + expect(perms.allowsRepo('app.bsky.feed.post', 'create')).toBe(true); 1041 + expect(perms.allowsRepo('app.bsky.feed.like', 'create')).toBe(false); 1086 1042 }); 1087 1043 1088 1044 test('multiple actions', () => { 1089 1045 const perms = new ScopePermissions('repo:*?action=create&action=update'); 1090 - assert.strictEqual(perms.allowsRepo('x', 'create'), true); 1091 - assert.strictEqual(perms.allowsRepo('x', 'update'), true); 1092 - assert.strictEqual(perms.allowsRepo('x', 'delete'), false); 1046 + expect(perms.allowsRepo('x', 'create')).toBe(true); 1047 + expect(perms.allowsRepo('x', 'update')).toBe(true); 1048 + expect(perms.allowsRepo('x', 'delete')).toBe(false); 1093 1049 }); 1094 1050 1095 1051 test('multiple scopes combine', () => { 1096 1052 const perms = new ScopePermissions( 1097 1053 'repo:app.bsky.feed.post?action=create repo:app.bsky.feed.like?action=delete', 1098 1054 ); 1099 - assert.strictEqual( 1100 - perms.allowsRepo('app.bsky.feed.post', 'create'), 1101 - true, 1102 - ); 1103 - assert.strictEqual( 1104 - perms.allowsRepo('app.bsky.feed.like', 'delete'), 1105 - true, 1106 - ); 1107 - assert.strictEqual( 1108 - perms.allowsRepo('app.bsky.feed.post', 'delete'), 1109 - false, 1110 - ); 1055 + expect(perms.allowsRepo('app.bsky.feed.post', 'create')).toBe(true); 1056 + expect(perms.allowsRepo('app.bsky.feed.like', 'delete')).toBe(true); 1057 + expect(perms.allowsRepo('app.bsky.feed.post', 'delete')).toBe(false); 1111 1058 }); 1112 1059 1113 1060 test('allowsRepo with query param format scopes', () => { 1114 1061 const perms = new ScopePermissions( 1115 1062 'atproto repo:app.bsky.feed.post?action=create', 1116 1063 ); 1117 - assert.strictEqual( 1118 - perms.allowsRepo('app.bsky.feed.post', 'create'), 1119 - true, 1120 - ); 1121 - assert.strictEqual( 1122 - perms.allowsRepo('app.bsky.feed.post', 'delete'), 1123 - true, 1124 - ); // atproto grants full access 1064 + expect(perms.allowsRepo('app.bsky.feed.post', 'create')).toBe(true); 1065 + expect(perms.allowsRepo('app.bsky.feed.post', 'delete')).toBe(true); // atproto grants full access 1125 1066 }); 1126 1067 }); 1127 1068 1128 1069 describe('blob scopes', () => { 1129 1070 test('wildcard allows any MIME', () => { 1130 1071 const perms = new ScopePermissions('blob:*/*'); 1131 - assert.strictEqual(perms.allowsBlob('image/png'), true); 1132 - assert.strictEqual(perms.allowsBlob('video/mp4'), true); 1072 + expect(perms.allowsBlob('image/png')).toBe(true); 1073 + expect(perms.allowsBlob('video/mp4')).toBe(true); 1133 1074 }); 1134 1075 1135 1076 test('type wildcard restricts to type', () => { 1136 1077 const perms = new ScopePermissions('blob:image/*'); 1137 - assert.strictEqual(perms.allowsBlob('image/png'), true); 1138 - assert.strictEqual(perms.allowsBlob('image/jpeg'), true); 1139 - assert.strictEqual(perms.allowsBlob('video/mp4'), false); 1078 + expect(perms.allowsBlob('image/png')).toBe(true); 1079 + expect(perms.allowsBlob('image/jpeg')).toBe(true); 1080 + expect(perms.allowsBlob('video/mp4')).toBe(false); 1140 1081 }); 1141 1082 1142 1083 test('specific MIME restricts exactly', () => { 1143 1084 const perms = new ScopePermissions('blob:image/png'); 1144 - assert.strictEqual(perms.allowsBlob('image/png'), true); 1145 - assert.strictEqual(perms.allowsBlob('image/jpeg'), false); 1085 + expect(perms.allowsBlob('image/png')).toBe(true); 1086 + expect(perms.allowsBlob('image/jpeg')).toBe(false); 1146 1087 }); 1147 1088 }); 1148 1089 1149 1090 describe('empty/no scope', () => { 1150 1091 test('no scope denies everything', () => { 1151 1092 const perms = new ScopePermissions(''); 1152 - assert.strictEqual(perms.allowsRepo('x', 'create'), false); 1153 - assert.strictEqual(perms.allowsBlob('image/png'), false); 1093 + expect(perms.allowsRepo('x', 'create')).toBe(false); 1094 + expect(perms.allowsBlob('image/png')).toBe(false); 1154 1095 }); 1155 1096 1156 1097 test('undefined scope denies everything', () => { 1157 1098 const perms = new ScopePermissions(undefined); 1158 - assert.strictEqual(perms.allowsRepo('x', 'create'), false); 1099 + expect(perms.allowsRepo('x', 'create')).toBe(false); 1159 1100 }); 1160 1101 }); 1161 1102 ··· 1164 1105 const perms = new ScopePermissions( 1165 1106 'repo:app.bsky.feed.post?action=create', 1166 1107 ); 1167 - assert.throws(() => perms.assertRepo('app.bsky.feed.like', 'create'), { 1168 - message: /Missing required scope/, 1169 - }); 1108 + expect(() => perms.assertRepo('app.bsky.feed.like', 'create')).toThrow( 1109 + /Missing required scope/, 1110 + ); 1170 1111 }); 1171 1112 1172 1113 test('does not throw when allowed', () => { 1173 1114 const perms = new ScopePermissions( 1174 1115 'repo:app.bsky.feed.post?action=create', 1175 1116 ); 1176 - assert.doesNotThrow(() => 1177 - perms.assertRepo('app.bsky.feed.post', 'create'), 1178 - ); 1117 + expect(() => perms.assertRepo('app.bsky.feed.post', 'create')).not.toThrow(); 1179 1118 }); 1180 1119 }); 1181 1120 1182 1121 describe('assertBlob', () => { 1183 1122 test('throws ScopeMissingError when denied', () => { 1184 1123 const perms = new ScopePermissions('blob:image/*'); 1185 - assert.throws(() => perms.assertBlob('video/mp4'), { 1186 - message: /Missing required scope/, 1187 - }); 1124 + expect(() => perms.assertBlob('video/mp4')).toThrow( 1125 + /Missing required scope/, 1126 + ); 1188 1127 }); 1189 1128 1190 1129 test('does not throw when allowed', () => { 1191 1130 const perms = new ScopePermissions('blob:image/*'); 1192 - assert.doesNotThrow(() => perms.assertBlob('image/png')); 1131 + expect(() => perms.assertBlob('image/png')).not.toThrow(); 1193 1132 }); 1194 1133 }); 1195 1134 }); ··· 1197 1136 describe('parseScopesForDisplay', () => { 1198 1137 test('parses identity-only scope', () => { 1199 1138 const result = parseScopesForDisplay('atproto'); 1200 - assert.strictEqual(result.hasAtproto, true); 1201 - assert.strictEqual(result.hasTransitionGeneric, false); 1202 - assert.strictEqual(result.repoPermissions.size, 0); 1203 - assert.deepStrictEqual(result.blobPermissions, []); 1139 + expect(result.hasAtproto).toBe(true); 1140 + expect(result.hasTransitionGeneric).toBe(false); 1141 + expect(result.repoPermissions.size).toBe(0); 1142 + expect(result.blobPermissions).toEqual([]); 1204 1143 }); 1205 1144 1206 1145 test('parses granular repo scopes', () => { 1207 1146 const result = parseScopesForDisplay( 1208 1147 'atproto repo:app.bsky.feed.post?action=create&action=update', 1209 1148 ); 1210 - assert.strictEqual(result.repoPermissions.size, 1); 1149 + expect(result.repoPermissions.size).toBe(1); 1211 1150 const postPerms = result.repoPermissions.get('app.bsky.feed.post'); 1212 - assert.deepStrictEqual(postPerms, { 1151 + expect(postPerms).toEqual({ 1213 1152 create: true, 1214 1153 update: true, 1215 1154 delete: false, ··· 1221 1160 'atproto repo:app.bsky.feed.post?action=create repo:app.bsky.feed.post?action=delete', 1222 1161 ); 1223 1162 const postPerms = result.repoPermissions.get('app.bsky.feed.post'); 1224 - assert.deepStrictEqual(postPerms, { 1163 + expect(postPerms).toEqual({ 1225 1164 create: true, 1226 1165 update: false, 1227 1166 delete: true, ··· 1230 1169 1231 1170 test('parses blob scopes', () => { 1232 1171 const result = parseScopesForDisplay('atproto blob:image/*'); 1233 - assert.deepStrictEqual(result.blobPermissions, ['image/*']); 1172 + expect(result.blobPermissions).toEqual(['image/*']); 1234 1173 }); 1235 1174 1236 1175 test('detects transition:generic', () => { 1237 1176 const result = parseScopesForDisplay('atproto transition:generic'); 1238 - assert.strictEqual(result.hasTransitionGeneric, true); 1177 + expect(result.hasTransitionGeneric).toBe(true); 1239 1178 }); 1240 1179 1241 1180 test('handles empty scope string', () => { 1242 1181 const result = parseScopesForDisplay(''); 1243 - assert.strictEqual(result.hasAtproto, false); 1244 - assert.strictEqual(result.hasTransitionGeneric, false); 1245 - assert.strictEqual(result.repoPermissions.size, 0); 1246 - assert.deepStrictEqual(result.blobPermissions, []); 1182 + expect(result.hasAtproto).toBe(false); 1183 + expect(result.hasTransitionGeneric).toBe(false); 1184 + expect(result.repoPermissions.size).toBe(0); 1185 + expect(result.blobPermissions).toEqual([]); 1247 1186 }); 1248 1187 });
+14
vitest.config.js
··· 1 + import { defineConfig } from 'vitest/config'; 2 + 3 + export default defineConfig({ 4 + test: { 5 + include: ['test/**/*.test.js'], 6 + testTimeout: 30000, 7 + hookTimeout: 60000, 8 + coverage: { 9 + provider: 'v8', 10 + reporter: ['text', 'html'], 11 + include: ['src/**/*.js'], 12 + }, 13 + }, 14 + });