+2 -2

package.json

··· 13 13 "@atcute/cid": "^1.0.1", 14 14 "@atcute/client": "^2.0.3", 15 15 "@atproto/crypto": "^0.4.2", 16 16 + "@badrap/valita": "^0.4.2", 16 17 "@mary/events": "npm:@jsr/mary__events@^0.1.0", 17 18 "@mary/solid-freeze": "npm:@externdefs/solid-freeze@^0.1.1", 18 19 "@mary/tar": "npm:@jsr/mary__tar@^0.2.4", 19 20 "nanoid": "^5.0.8", 20 21 "native-file-system-adapter": "^3.0.1", 21 22 "solid-js": "^1.9.2", 22 22 - "uint8arrays": "^5.1.0", 23 23 - "valibot": "1.0.0-beta.2" 23 23 + "uint8arrays": "^5.1.0" 24 24 }, 25 25 "devDependencies": { 26 26 "@tailwindcss/forms": "^0.5.9",

+9 -15

pnpm-lock.yaml

··· 26 26 '@atproto/crypto': 27 27 specifier: ^0.4.2 28 28 version: 0.4.2 29 29 + '@badrap/valita': 30 30 + specifier: ^0.4.2 31 31 + version: 0.4.2 29 32 '@mary/events': 30 33 specifier: npm:@jsr/mary__events@^0.1.0 31 34 version: '@jsr/mary__events@0.1.0' ··· 47 50 uint8arrays: 48 51 specifier: ^5.1.0 49 52 version: 5.1.0 50 50 - valibot: 51 51 - specifier: 1.0.0-beta.2 52 52 - version: 1.0.0-beta.2(typescript@5.7.0-beta) 53 53 devDependencies: 54 54 '@tailwindcss/forms': 55 55 specifier: ^0.5.9 ··· 197 197 '@babel/types@7.26.0': 198 198 resolution: {integrity: sha512-Z/yiTPj+lDVnF7lWeKCIJzaIkI0vYO87dMpZ4bg4TDrFe4XXLFWL1TbXU27gBP3QccxV9mZICCrnjnYlJjXHOA==} 199 199 engines: {node: '>=6.9.0'} 200 200 + 201 201 + '@badrap/valita@0.4.2': 202 202 + resolution: {integrity: sha512-Mwmr7k2iK0Yy0POLnAFUgab2mxKYeIsYXHY7sg3jo8XFsFHbG0SBmTcktXD0uW8N4WZePKf8s68QV7QDTGSdHA==} 203 203 + engines: {node: '>= 18'} 200 204 201 205 '@cloudflare/kv-asset-handler@0.3.4': 202 206 resolution: {integrity: sha512-YLPHc8yASwjNkmcDMQMY35yiWjoKAKnhUbPRszBRS0YgH+IXtsMp61j+yTcnCE3oO2DgP0U3iejLC8FTtKDC8Q==} ··· 1457 1461 util-deprecate@1.0.2: 1458 1462 resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} 1459 1463 1460 1460 - valibot@1.0.0-beta.2: 1461 1461 - resolution: {integrity: sha512-XwAXmUPdB0Hikm6M18dD/a+j+57KA0dFlna5Yh77LBeeItSIQMwyZOjf8E2nWkhDtQ+Ie4GiaZPkLmaszH/4+w==} 1462 1462 - peerDependencies: 1463 1463 - typescript: '>=5' 1464 1464 - peerDependenciesMeta: 1465 1465 - typescript: 1466 1466 - optional: true 1467 1467 - 1468 1464 validate-html-nesting@1.2.2: 1469 1465 resolution: {integrity: sha512-hGdgQozCsQJMyfK5urgFcWEqsSSrK63Awe0t/IMR0bZ0QMtnuaiHzThW81guu3qx9abLi99NEuiaN6P9gVYsNg==} 1470 1466 ··· 1727 1723 dependencies: 1728 1724 '@babel/helper-string-parser': 7.25.9 1729 1725 '@babel/helper-validator-identifier': 7.25.9 1726 1726 + 1727 1727 + '@badrap/valita@0.4.2': {} 1730 1728 1731 1729 '@cloudflare/kv-asset-handler@0.3.4': 1732 1730 dependencies: ··· 2770 2768 picocolors: 1.1.1 2771 2769 2772 2770 util-deprecate@1.0.2: {} 2773 2773 - 2774 2774 - valibot@1.0.0-beta.2(typescript@5.7.0-beta): 2775 2775 - optionalDependencies: 2776 2776 - typescript: 5.7.0-beta 2777 2771 2778 2772 validate-html-nesting@1.2.2: {} 2779 2773

+1 -3

src/api/queries/did-doc.ts

··· 1 1 - import * as v from 'valibot'; 2 2 - 3 1 import { At } from '@atcute/client/lexicons'; 4 2 5 3 import { didDocument, DidDocument } from '../types/did-doc'; ··· 50 48 throw new Error(`unsupported did method`); 51 49 } 52 50 53 53 - return v.parse(didDocument, rawDoc); 51 51 + return didDocument.parse(rawDoc, { mode: 'passthrough' }); 54 52 };

+1 -3

src/api/queries/plc.ts

··· 1 1 - import * as v from 'valibot'; 2 2 - 3 1 import { At } from '@atcute/client/lexicons'; 4 2 5 3 import { plcLogEntries } from '../types/plc'; ··· 12 10 } 13 11 14 12 const json = await response.json(); 15 15 - return v.parse(plcLogEntries, json); 13 13 + return plcLogEntries.parse(json); 16 14 };

+44 -66

src/api/types/did-doc.ts

··· 1 1 - import * as v from 'valibot'; 1 1 + import * as v from '@badrap/valita'; 2 2 3 3 import { didString, serviceUrlString, urlString } from './strings'; 4 4 + 5 5 + const PUBLIC_KEY_MULTIBASE_RE = /^z[a-km-zA-HJ-NP-Z1-9]+$/; 4 6 5 7 const verificationMethod = v.object({ 6 8 id: v.string(), 7 9 type: v.string(), 8 10 controller: didString, 9 9 - publicKeyMultibase: v.optional( 10 10 - v.pipe( 11 11 - v.string(), 12 12 - v.regex(/^z[a-km-zA-HJ-NP-Z1-9]+$|^u[a-zA-Z0-9-_]+$/, 'must be a valid multibase value'), 13 13 - ), 14 14 - ), 11 11 + publicKeyMultibase: v 12 12 + .string() 13 13 + .assert((input) => PUBLIC_KEY_MULTIBASE_RE.test(input), `must be a valid base58btc multibase key`), 15 14 }); 16 15 17 17 - const service = v.pipe( 18 18 - v.object({ 16 16 + const service = v 17 17 + .object({ 19 18 id: v.string(), 20 19 type: v.string(), 21 21 - serviceEndpoint: v.union([urlString, v.record(v.string(), urlString), v.array(urlString)]), 22 22 - }), 23 23 - v.forward( 24 24 - v.check((input) => { 25 25 - switch (input.type) { 26 26 - case 'AtprotoPersonalDataServer': 27 27 - case 'AtprotoLabeler': 28 28 - case 'BskyFeedGenerator': 29 29 - case 'BskyNotificationService': 30 30 - return v.is(serviceUrlString, input.serviceEndpoint); 20 20 + serviceEndpoint: v.union(urlString, v.record(urlString), v.array(urlString)), 21 21 + }) 22 22 + .chain((input) => { 23 23 + switch (input.type) { 24 24 + case 'AtprotoPersonalDataServer': 25 25 + case 'AtprotoLabeler': 26 26 + case 'BskyFeedGenerator': 27 27 + case 'BskyNotificationService': { 28 28 + const result = serviceUrlString.try(input.serviceEndpoint); 29 29 + if (!result.ok) { 30 30 + return v.err({ 31 31 + message: `must be a valid atproto service url`, 32 32 + path: ['serviceEndpoint'], 33 33 + }); 34 34 + } 31 35 } 36 36 + } 32 37 33 33 - return true; 34 34 - }, 'must be a valid atproto service endpoint'), 35 35 - ['serviceEndpoint'], 36 36 - ), 37 37 - ); 38 38 + return v.ok(input); 39 39 + }); 38 40 39 41 export const didDocument = v.object({ 40 42 '@context': v.array(urlString), 41 43 id: didString, 42 42 - alsoKnownAs: v.optional(v.array(urlString), []), 43 43 - verificationMethod: v.optional(v.array(verificationMethod), []), 44 44 - service: v.optional( 45 45 - v.pipe( 46 46 - v.array(service), 47 47 - v.rawCheck(({ dataset, addIssue }) => { 48 48 - if (dataset.typed) { 49 49 - const set = new Set<string>(); 50 50 - const services = dataset.value; 44 44 + alsoKnownAs: v.array(urlString).optional(() => []), 45 45 + verificationMethod: v.array(verificationMethod).optional(() => []), 46 46 + service: v.array(service).chain((input) => { 47 47 + for (let i = 0, len = input.length; i < len; i++) { 48 48 + const service = input[i]; 49 49 + const id = service.id; 51 50 52 52 - for (let idx = 0, len = services.length; idx < len; idx++) { 53 53 - const service = services[idx]; 54 54 - const id = service.id; 51 51 + for (let j = 0; j < i; j++) { 52 52 + if (input[j].id === id) { 53 53 + return v.err({ 54 54 + message: `duplicate service id`, 55 55 + path: [i, 'id'], 56 56 + }); 57 57 + } 58 58 + } 59 59 + } 55 60 56 56 - if (!set.has(id)) { 57 57 - set.add(id); 58 58 - } else { 59 59 - addIssue({ 60 60 - message: `duplicate service id`, 61 61 - path: [ 62 62 - { 63 63 - type: 'array', 64 64 - origin: 'value', 65 65 - input: services, 66 66 - key: idx, 67 67 - value: service, 68 68 - }, 69 69 - { 70 70 - type: 'object', 71 71 - origin: 'value', 72 72 - input: service, 73 73 - key: 'id', 74 74 - value: id, 75 75 - }, 76 76 - ], 77 77 - }); 78 78 - } 79 79 - } 80 80 - } 81 81 - }), 82 82 - ), 83 83 - [], 84 84 - ), 61 61 + return v.ok(input); 62 62 + }), 85 63 }); 86 64 87 87 - export type DidDocument = v.InferOutput<typeof didDocument>; 65 65 + export type DidDocument = v.Infer<typeof didDocument>; 88 66 89 67 export const getPdsEndpoint = (doc: DidDocument): string | undefined => { 90 68 return getServiceEndpoint(doc, '#atproto_pds', 'AtprotoPersonalDataServer');

+56 -61

src/api/types/plc.ts

··· 1 1 - import * as v from 'valibot'; 1 1 + import * as v from '@badrap/valita'; 2 2 3 3 import { didKeyString, didString, handleString, serviceUrlString, urlString } from './strings'; 4 4 5 5 - export const legacyGenesisOp = v.object({ 5 5 + const legacyGenesisOp = v.object({ 6 6 type: v.literal('create'), 7 7 signingKey: didKeyString, 8 8 recoveryKey: didKeyString, ··· 11 11 prev: v.null(), 12 12 sig: v.string(), 13 13 }); 14 14 - export type PlcLegacyGenesisOp = v.InferOutput<typeof legacyGenesisOp>; 15 14 16 16 - export const tombstoneOp = v.object({ 15 15 + const tombstoneOp = v.object({ 17 16 type: v.literal('plc_tombstone'), 18 17 prev: v.string(), 19 18 sig: v.string(), 20 19 }); 21 21 - export type PlcTombstoneOp = v.InferOutput<typeof tombstoneOp>; 22 20 23 23 - export const service = v.object({ 21 21 + const service = v.object({ 24 22 type: v.string(), 25 23 endpoint: urlString, 26 24 }); 27 27 - export type Service = v.InferOutput<typeof service>; 25 25 + export type Service = v.Infer<typeof service>; 28 26 29 27 const updateOp = v.object({ 30 28 type: v.literal('plc_operation'), 31 31 - prev: v.nullable(v.string()), 29 29 + prev: v.string().nullable(), 32 30 sig: v.string(), 33 33 - rotationKeys: v.pipe( 34 34 - v.array(didKeyString), 35 35 - v.minLength(1), 36 36 - v.check((v) => new Set(v).size === v.length, `must contain unique keys`), 37 37 - ), 38 38 - verificationMethods: v.record(v.string(), didKeyString), 31 31 + rotationKeys: v.array(didKeyString).chain((input) => { 32 32 + if (input.length === 0) { 33 33 + return v.err({ message: `missing rotation keys` }); 34 34 + } 35 35 + 36 36 + for (let i = 0, len = input.length; i < len; i++) { 37 37 + const key = input[i]; 38 38 + 39 39 + for (let j = 0; j < i; j++) { 40 40 + if (input[j] === key) { 41 41 + return v.err({ 42 42 + message: `duplicate rotation key`, 43 43 + path: [i], 44 44 + }); 45 45 + } 46 46 + } 47 47 + } 48 48 + 49 49 + return v.ok(input); 50 50 + }), 51 51 + verificationMethods: v.record(didKeyString), 39 52 alsoKnownAs: v.array(urlString), 40 40 - services: v.record(v.string(), service), 53 53 + services: v.record(service), 41 54 }); 42 42 - export type PlcUpdateOp = v.InferOutput<typeof updateOp>; 55 55 + export type PlcUpdateOp = v.Infer<typeof updateOp>; 43 56 44 44 - export const plcOperation = v.union([legacyGenesisOp, tombstoneOp, updateOp]); 45 45 - export type PlcOperation = v.InferOutput<typeof plcOperation>; 57 57 + const plcOperation = v.union(legacyGenesisOp, tombstoneOp, updateOp); 46 58 47 59 export const plcLogEntry = v.object({ 48 60 did: didString, 49 61 cid: v.string(), 50 62 operation: plcOperation, 51 63 nullified: v.boolean(), 52 52 - createdAt: v.pipe( 53 53 - v.string(), 54 54 - v.check((dateString) => { 55 55 - const date = new Date(dateString); 56 56 - return !Number.isNaN(date.getTime()); 57 57 - }), 58 58 - ), 64 64 + createdAt: v 65 65 + .string() 66 66 + .assert((input) => !Number.isNaN(new Date(input).getTime()), `must be a valid datetime string`), 59 67 }); 60 60 - export type PlcLogEntry = v.InferOutput<typeof plcLogEntry>; 68 68 + export type PlcLogEntry = v.Infer<typeof plcLogEntry>; 61 69 62 70 export const plcLogEntries = v.array(plcLogEntry); 63 71 64 64 - export const updatePayload = v.object({ 65 65 - ...v.omit(updateOp, ['type', 'prev', 'sig', 'services']).entries, 72 72 + export const updatePayload = updateOp.omit('type', 'prev', 'sig').extend({ 66 73 services: v.record( 67 67 - v.string(), 68 68 - v.pipe( 69 69 - v.object({ 70 70 - type: v.string(), 71 71 - endpoint: urlString, 72 72 - }), 73 73 - v.rawTransform(({ dataset, addIssue, NEVER }) => { 74 74 - const input = dataset.value; 74 74 + service.chain((input) => { 75 75 + switch (input.type) { 76 76 + case 'AtprotoPersonalDataServer': 77 77 + case 'AtprotoLabeler': 78 78 + case 'BskyFeedGenerator': 79 79 + case 'BskyNotificationService': { 80 80 + const endpoint = input.endpoint; 81 81 + const result = serviceUrlString.try(endpoint); 75 82 76 76 - switch (input.type) { 77 77 - case 'AtprotoPersonalDataServer': 78 78 - case 'AtprotoLabeler': 79 79 - case 'BskyFeedGenerator': 80 80 - case 'BskyNotificationService': { 81 81 - if (!v.is(serviceUrlString, input.endpoint)) { 82 82 - addIssue({ 83 83 - message: `must be a valid atproto service endpoint`, 84 84 - path: [ 85 85 - { 86 86 - type: 'object', 87 87 - origin: 'value', 88 88 - input: input, 89 89 - key: 'endpoint', 90 90 - value: input.endpoint, 91 91 - }, 92 92 - ], 93 93 - }); 83 83 + if (!result.ok) { 84 84 + return v.err({ 85 85 + message: `must be a valid atproto service url`, 86 86 + path: ['endpoint'], 87 87 + }); 88 88 + } 94 89 95 95 - return NEVER; 96 96 - } 90 90 + const trimmed = endpoint.replace(/\/$/, ''); 97 91 98 98 - return { ...input, endpoint: input.endpoint.replace(/\/$/, '') }; 92 92 + if (endpoint !== trimmed) { 93 93 + return v.ok({ ...input, endpoint: trimmed }); 99 94 } 100 95 } 96 96 + } 101 97 102 102 - return input; 103 103 - }), 104 104 - ), 98 98 + return v.ok(input); 99 99 + }), 105 100 ), 106 101 }); 107 107 - export type PlcUpdatePayload = v.InferOutput<typeof updatePayload>; 102 102 + export type PlcUpdatePayload = v.Infer<typeof updatePayload>;

+22 -22

src/api/types/strings.ts

··· 1 1 - import * as v from 'valibot'; 1 1 + import * as v from '@badrap/valita'; 2 2 3 3 - import { DID_RE, HANDLE_RE } from '../utils/strings'; 3 3 + import { DID_KEY_RE, DID_RE, HANDLE_RE } from '../utils/strings'; 4 4 5 5 - export const didString = v.pipe(v.string(), v.regex(DID_RE, 'must be a valid did')); 6 6 - export const handleString = v.pipe(v.string(), v.regex(HANDLE_RE, 'must be a valid handle')); 5 5 + export const didString = v.string().assert((input) => DID_RE.test(input), `must be a valid did`); 7 6 8 8 - export const urlString = v.pipe(v.string(), v.url()); 7 7 + export const didKeyString = v.string().assert((input) => DID_KEY_RE.test(input), `must be a valid did:key`); 9 8 10 10 - export const serviceUrlString = v.pipe( 11 11 - v.string(), 12 12 - v.check((urlString) => { 13 13 - const url = URL.parse(urlString); 9 9 + export const handleString = v.string().assert((input) => HANDLE_RE.test(input), `must be a valid handle`); 14 10 15 15 - return ( 16 16 - url !== null && 17 17 - (url.protocol === 'https:' || url.protocol === 'http:') && 18 18 - url.pathname === '/' && 19 19 - url.search === '' && 20 20 - url.hash === '' 21 21 - ); 22 22 - }, 'must be a valid atproto service url'), 23 23 - ); 11 11 + export const urlString = v.string().assert((input) => URL.canParse(input), `must be a valid url`); 24 12 25 25 - export const didKeyString = v.pipe( 26 26 - v.string(), 27 27 - v.regex(/^did:key:z[a-km-zA-HJ-NP-Z1-9]+$/, 'must be a valid did:key'), 28 28 - ); 13 13 + export const serviceUrlString = v.string().assert((input) => { 14 14 + const url = URL.parse(input); 15 15 + 16 16 + return ( 17 17 + url !== null && 18 18 + (url.protocol === 'https:' || url.protocol === 'http:') && 19 19 + url.pathname === '/' && 20 20 + url.search === '' && 21 21 + url.hash === '' 22 22 + ); 23 23 + }, `must be a valid atproto service url`); 24 24 + 25 25 + export const isServiceUrlString = (str: string) => { 26 26 + const result = serviceUrlString.try(str); 27 27 + return result.ok; 28 28 + };

+2

src/api/utils/strings.ts

··· 9 9 10 10 export const DID_WEB_RE = /^([a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*(?:\.[a-zA-Z]{2,}))$/; 11 11 12 12 + export const DID_KEY_RE = /^did:key:z[a-km-zA-HJ-NP-Z1-9]+$/; 13 13 + 12 14 export const HANDLE_RE = /^[a-zA-Z0-9\-]+(?:\.[a-zA-Z0-9\-]+)*(?:\.[a-zA-Z]{2,})$/; 13 15 14 16 export const DID_OR_HANDLE_RE =

-21

src/globals/multiagent.ts

··· 1 1 - import * as v from 'valibot'; 2 2 - 3 3 - import { didString, serviceUrlString } from '~/api/types/strings'; 4 4 - 5 5 - const hexColorString = v.pipe(v.string(), v.regex(v.HEX_COLOR_REGEX)); 6 6 - 7 7 - const multiagentAccountData = v.object({ 8 8 - did: v.pipe(didString, v.readonly()), 9 9 - service: serviceUrlString, 10 10 - session: v.unknown(), 11 11 - scope: v.union([v.literal('full'), v.literal('privileged'), v.literal('limited')]), 12 12 - name: v.string(), 13 13 - color: hexColorString, 14 14 - }); 15 15 - 16 16 - const multiagentStorage = v.object({ 17 17 - active: v.optional(didString), 18 18 - accounts: v.array(multiagentAccountData), 19 19 - }); 20 20 - 21 21 - console.log(multiagentStorage);

+2 -3

src/views/blob/blob-export.tsx

··· 1 1 import { FileSystemWritableFileStream, showSaveFilePicker } from 'native-file-system-adapter'; 2 2 import { createSignal } from 'solid-js'; 3 3 - import * as v from 'valibot'; 4 3 5 4 import { simpleFetchHandler, XRPC, XRPCError } from '@atcute/client'; 6 5 import { At } from '@atcute/client/lexicons'; ··· 9 8 import { getDidDocument } from '~/api/queries/did-doc'; 10 9 import { resolveHandleViaAppView, resolveHandleViaPds } from '~/api/queries/handle'; 11 10 import { getPdsEndpoint } from '~/api/types/did-doc'; 12 12 - import { serviceUrlString } from '~/api/types/strings'; 11 11 + import { isServiceUrlString } from '~/api/types/strings'; 13 12 import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings'; 14 13 15 14 import { makeAbortable } from '~/lib/utils/abortable'; ··· 276 275 const input = ev.currentTarget; 277 276 const value = input.value; 278 277 279 279 - if (value !== '' && !v.is(serviceUrlString, value)) { 278 278 + if (value !== '' && isServiceUrlString(value)) { 280 279 input.setCustomValidity('Must be a valid service URL'); 281 280 } else { 282 281 input.setCustomValidity('');

+2 -3

src/views/identity/did-lookup.tsx

··· 1 1 import { Match, Switch } from 'solid-js'; 2 2 - import * as v from 'valibot'; 3 2 4 3 import { At } from '@atcute/client/lexicons'; 5 4 6 5 import { getDidDocument } from '~/api/queries/did-doc'; 7 6 import { resolveHandleViaAppView } from '~/api/queries/handle'; 8 8 - import { serviceUrlString } from '~/api/types/strings'; 7 7 + import { isServiceUrlString } from '~/api/types/strings'; 9 8 import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings'; 10 9 11 10 import { useTitle } from '~/lib/navigation/router'; ··· 124 123 {doc.service.map(({ id, type, serviceEndpoint }, idx) => { 125 124 const isString = typeof serviceEndpoint === 'string'; 126 125 const isURL = isString && URL.canParse('' + serviceEndpoint); 127 127 - const isServiceUrl = isString && v.is(serviceUrlString, serviceEndpoint); 126 126 + const isServiceUrl = isString && isServiceUrlString(serviceEndpoint); 128 127 129 128 const isPDS = type === 'AtprotoPersonalDataServer'; 130 129 const isLabeler = type === 'AtprotoLabeler';

+4 -9

src/views/identity/plc-applicator.tsx

··· 8 8 import { P256Keypair, Secp256k1Keypair, verifySignature } from '@atproto/crypto'; 9 9 import * as uint8arrays from 'uint8arrays'; 10 10 11 11 - import * as v from 'valibot'; 12 12 - 13 11 import { getDidDocument } from '~/api/queries/did-doc'; 14 12 import { resolveHandleViaAppView } from '~/api/queries/handle'; 15 13 import { getPlcAuditLogs } from '~/api/queries/plc'; ··· 608 606 return; 609 607 } 610 608 611 611 - const result = v.safeParse(updatePayload, json); 612 612 - if (!result.success) { 613 613 - const issue = result.issues[0]; 614 614 - const path = v.getDotPath(issue); 615 615 - 616 616 - setError({ step: 4, message: `Error at '.${path}'\n${issue.message}` }); 609 609 + const result = updatePayload.try(json); 610 610 + if (!result.ok) { 611 611 + setError({ step: 4, message: result.message }); 617 612 return; 618 613 } 619 614 620 620 - states.payload = result.output; 615 615 + states.payload = result.value; 621 616 622 617 setStep(5); 623 618 }}

+2 -3

src/views/repository/repo-export.tsx

··· 1 1 import { type FileSystemFileHandle, showSaveFilePicker } from 'native-file-system-adapter'; 2 2 import { createSignal } from 'solid-js'; 3 3 - import * as v from 'valibot'; 4 3 5 4 import { At } from '@atcute/client/lexicons'; 6 5 7 6 import { getDidDocument } from '~/api/queries/did-doc'; 8 7 import { resolveHandleViaAppView, resolveHandleViaPds } from '~/api/queries/handle'; 9 8 import { getPdsEndpoint } from '~/api/types/did-doc'; 10 10 - import { serviceUrlString } from '~/api/types/strings'; 9 9 + import { isServiceUrlString } from '~/api/types/strings'; 11 10 import { DID_OR_HANDLE_RE, isDid } from '~/api/utils/strings'; 12 11 13 12 import { useTitle } from '~/lib/navigation/router'; ··· 202 201 const input = ev.currentTarget; 203 202 const value = input.value; 204 203 205 205 - if (value !== '' && !v.is(serviceUrlString, value)) { 204 204 + if (value !== '' && isServiceUrlString(value)) { 206 205 input.setCustomValidity('Must be a valid service URL'); 207 206 } else { 208 207 input.setCustomValidity('');